- Changed the terminology of monoids ("append" -> "compose", "unit" -> "identity").

8 files changed, 36 insertions, 36 deletions

diff --git a/stdlib/test/test/lux/data/bool.lux b/stdlib/test/test/lux/data/bool.lux
index f26c98a43..bbc867581 100644
--- a/stdlib/test/test/lux/data/bool.lux
+++ b/stdlib/test/test/lux/data/bool.lux
@@ -11,10 +11,10 @@
   (test "" (and (not (and value (not value)))
                 (or value (not value))
 
-                (not (:: Or@Monoid<Bool> unit))
-                (:: Or@Monoid<Bool> append value (not value))
-                (:: And@Monoid<Bool> unit)
-                (not (:: And@Monoid<Bool> append value (not value)))
+                (not (:: Or@Monoid<Bool> identity))
+                (:: Or@Monoid<Bool> compose value (not value))
+                (:: And@Monoid<Bool> identity)
+                (not (:: And@Monoid<Bool> compose value (not value)))
                 
                 (:: Eq<Bool> = value (not (not value)))
                 (not (:: Eq<Bool> = value (not value)))
diff --git a/stdlib/test/test/lux/data/coll/array.lux b/stdlib/test/test/lux/data/coll/array.lux
index 3f344a1be..81f8144d2 100644
--- a/stdlib/test/test/lux/data/coll/array.lux
+++ b/stdlib/test/test/lux/data/coll/array.lux
@@ -113,7 +113,7 @@
    right (R;array sizeR R;nat)
    #let [(^open) &;Monoid<Array>
          (^open) (&;Eq<Array> number;Eq<Nat>)
-         fusion (append left right)]]
+         fusion (compose left right)]]
   ($_ seq
       (test "Appending two arrays should produce a new one twice as large."
             (n.= (n.+ sizeL sizeR) (&;size fusion)))
diff --git a/stdlib/test/test/lux/data/coll/list.lux b/stdlib/test/test/lux/data/coll/list.lux
index 087c9d831..a3d091625 100644
--- a/stdlib/test/test/lux/data/coll/list.lux
+++ b/stdlib/test/test/lux/data/coll/list.lux
@@ -82,7 +82,7 @@
                   inits (maybe;assume (&;inits sample))
                   last (maybe;assume (&;last sample))]
               (= sample
-                 (append inits (list last)))))
+                 (compose inits (list last)))))
 
       (test "Functor should go over every element of the list."
             (let [(^open) &;Functor<List>
@@ -96,15 +96,15 @@
                   [left right] (&;split idx sample)
                   [left' right'] (&;split-with n.even? sample)]
               (and (= sample
-                      (append left right))
+                      (compose left right))
                    (= sample
-                      (append left' right'))
+                      (compose left' right'))
                    (= sample
-                      (append (&;take idx sample)
-                              (&;drop idx sample)))
+                      (compose (&;take idx sample)
+                               (&;drop idx sample)))
                    (= sample
-                      (append (&;take-while n.even? sample)
-                              (&;drop-while n.even? sample)))
+                      (compose (&;take-while n.even? sample)
+                               (&;drop-while n.even? sample)))
                    )))
 
       (test "Segmenting the list in pairs should yield as many elements as N/2."
@@ -162,9 +162,9 @@
 
       (test "List append is a monoid."
             (let [(^open) &;Monoid<List>]
-              (and (= sample (append unit sample))
-                   (= sample (append sample unit))
-                   (let [[left right] (&;split size (append sample other-sample))]
+              (and (= sample (compose identity sample))
+                   (= sample (compose sample identity))
+                   (let [[left right] (&;split size (compose sample other-sample))]
                      (and (= sample left)
                           (= other-sample right))))))
 
@@ -177,7 +177,7 @@
       (test "List concatenation is a monad."
             (let [(^open) &;Monad<List>
                   (^open) &;Monoid<List>]
-              (= (append sample other-sample)
+              (= (compose sample other-sample)
                  (join (list sample other-sample)))))
 
       (test "You can find any value that satisfies some criterium, if such values exist in the list."
diff --git a/stdlib/test/test/lux/data/coll/seq.lux b/stdlib/test/test/lux/data/coll/seq.lux
index 15d6241de..c6d25a0d8 100644
--- a/stdlib/test/test/lux/data/coll/seq.lux
+++ b/stdlib/test/test/lux/data/coll/seq.lux
@@ -53,7 +53,7 @@
                             (&;prepend extra sample)
                             extra)
                  (&;member? number;Eq<Nat>
-                            (&;append extra sample)
+                            (&;compose extra sample)
                             extra)))
       
       (test "Can do random access to seq elements."
@@ -64,7 +64,7 @@
 
                             _
                             false))
-                 (|> (&;append extra sample)
+                 (|> (&;compose extra sample)
                      (&;nth size)
                      (case> (#;Some reference)
                             (n.= reference extra)
diff --git a/stdlib/test/test/lux/data/coll/vector.lux b/stdlib/test/test/lux/data/coll/vector.lux
index 2d7d00576..e605805a8 100644
--- a/stdlib/test/test/lux/data/coll/vector.lux
+++ b/stdlib/test/test/lux/data/coll/vector.lux
@@ -67,6 +67,6 @@
                  (&/= (&/map n.inc sample)  (&/apply (&/wrap n.inc) sample))))
 
       (test "Vector concatenation is a monad."
-            (&/= (&/append sample other-sample)
+            (&/= (&/compose sample other-sample)
                  (&/join (&;vector sample other-sample))))
       ))
diff --git a/stdlib/test/test/lux/data/identity.lux b/stdlib/test/test/lux/data/identity.lux
index e0e32ca04..494811947 100644
--- a/stdlib/test/test/lux/data/identity.lux
+++ b/stdlib/test/test/lux/data/identity.lux
@@ -12,15 +12,15 @@
         (^open "&/") &;CoMonad<Identity>]
     ($_ seq
         (test "Functor does not affect values."
-              (Text/= "yololol" (&/map (Text/append "yolo") "lol")))
+              (Text/= "yololol" (&/map (Text/compose "yolo") "lol")))
         
         (test "Applicative does not affect values."
               (and (Text/= "yolo" (&/wrap "yolo"))
-                   (Text/= "yololol" (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
+                   (Text/= "yololol" (&/apply (&/wrap (Text/compose "yolo")) (&/wrap "lol")))))
         
         (test "Monad does not affect values."
               (Text/= "yololol" (do &;Monad<Identity>
-                                  [f (wrap Text/append)
+                                  [f (wrap Text/compose)
                                    a (wrap "yolo")
                                    b (wrap "lol")]
                                   (wrap (f a b)))))
@@ -28,7 +28,7 @@
         (test "CoMonad does not affect values."
               (and (Text/= "yololol" (&/unwrap "yololol"))
                    (Text/= "yololol" (be &;CoMonad<Identity>
-                                       [f Text/append
+                                       [f Text/compose
                                         a "yolo"
                                         b "lol"]
                                        (f a b)))))
diff --git a/stdlib/test/test/lux/data/maybe.lux b/stdlib/test/test/lux/data/maybe.lux
index 35beef257..fed83c4b9 100644
--- a/stdlib/test/test/lux/data/maybe.lux
+++ b/stdlib/test/test/lux/data/maybe.lux
@@ -20,25 +20,25 @@
                    (not (Maybe/= (#;Some "yolo") #;None))))
 
         (test "Monoid respects Maybe."
-              (and (Maybe/= #;None &/unit)
-                   (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") (#;Some "lol")))
-                   (Maybe/= (#;Some "yolo") (&/append (#;Some "yolo") #;None))
-                   (Maybe/= (#;Some "lol") (&/append #;None (#;Some "lol")))
-                   (Maybe/= #;None (: (Maybe Text) (&/append #;None #;None)))))
+              (and (Maybe/= #;None &/identity)
+                   (Maybe/= (#;Some "yolo") (&/compose (#;Some "yolo") (#;Some "lol")))
+                   (Maybe/= (#;Some "yolo") (&/compose (#;Some "yolo") #;None))
+                   (Maybe/= (#;Some "lol") (&/compose #;None (#;Some "lol")))
+                   (Maybe/= #;None (: (Maybe Text) (&/compose #;None #;None)))))
         
         (test "Functor respects Maybe."
-              (and (Maybe/= #;None (&/map (Text/append "yolo") #;None))
-                   (Maybe/= (#;Some "yololol") (&/map (Text/append "yolo") (#;Some "lol")))))
+              (and (Maybe/= #;None (&/map (Text/compose "yolo") #;None))
+                   (Maybe/= (#;Some "yololol") (&/map (Text/compose "yolo") (#;Some "lol")))))
         
         (test "Applicative respects Maybe."
               (and (Maybe/= (#;Some "yolo") (&/wrap "yolo"))
                    (Maybe/= (#;Some "yololol")
-                            (&/apply (&/wrap (Text/append "yolo")) (&/wrap "lol")))))
+                            (&/apply (&/wrap (Text/compose "yolo")) (&/wrap "lol")))))
         
         (test "Monad respects Maybe."
               (Maybe/= (#;Some "yololol")
                        (do &;Monad<Maybe>
-                         [f (wrap Text/append)
+                         [f (wrap Text/compose)
                           a (wrap "yolo")
                           b (wrap "lol")]
                          (wrap (f a b)))))
diff --git a/stdlib/test/test/lux/data/number.lux b/stdlib/test/test/lux/data/number.lux
index b715119c6..c33d06856 100644
--- a/stdlib/test/test/lux/data/number.lux
+++ b/stdlib/test/test/lux/data/number.lux
@@ -86,10 +86,10 @@
       #let [(^open) <Number>
             (^open) <Order>
             (^open) <Monoid>]]
-     (test "Appending to unit doesn't change the value."
-           (and (= x (append unit x))
-                (= x (append x unit))
-                (= unit (append unit unit)))))]
+     (test "Composing with identity doesn't change the value."
+           (and (= x (compose identity x))
+                (= x (compose x identity))
+                (= identity (compose identity identity)))))]
 
   ["Nat/Add"  R;nat  Number<Nat>  Order<Nat>  Add@Monoid<Nat>  (n.% +1000)  (function [_] true)]
   ["Nat/Mul"  R;nat  Number<Nat>  Order<Nat>  Mul@Monoid<Nat>  (n.% +1000)  (function [_] true)]