- Re-named "equality" to "equivalence".

22 files changed, 97 insertions, 97 deletions

diff --git a/stdlib/source/lux/data/bool.lux b/stdlib/source/lux/data/bool.lux
index 21ae0526f..88c1011e5 100644
--- a/stdlib/source/lux/data/bool.lux
+++ b/stdlib/source/lux/data/bool.lux
@@ -1,20 +1,20 @@
 (.module:
   lux
   (lux (control [monoid #+ Monoid]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 hash
                 [codec #+ Codec])
        function))
 
 ## [Structures]
-(struct: #export _ (Eq Bool)
+(struct: #export _ (Equivalence Bool)
   (def: (= x y)
     (if x
       y
       (not y))))
 
 (struct: #export _ (Hash Bool)
-  (def: eq Eq<Bool>)
+  (def: eq Equivalence<Bool>)
   (def: (hash value)
     (case value
       true +1
diff --git a/stdlib/source/lux/data/coll/array.lux b/stdlib/source/lux/data/coll/array.lux
index 3e649fc7d..8f3bee0c3 100644
--- a/stdlib/source/lux/data/coll/array.lux
+++ b/stdlib/source/lux/data/coll/array.lux
@@ -2,7 +2,7 @@
   lux
   (lux (control [monoid #+ Monoid]
                 [functor #+ Functor]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 fold)
        (data (coll [list "list/" Fold<List>])
              [product])
@@ -149,8 +149,8 @@
                #.None
                output)))))
 
-(struct: #export (Eq<Array> Eq<a>)
-  (All [a] (-> (Eq a) (Eq (Array a))))
+(struct: #export (Equivalence<Array> Equivalence<a>)
+  (All [a] (-> (Equivalence a) (Equivalence (Array a))))
   (def: (= xs ys)
     (let [sxs (size xs)
           sxy (size ys)]
@@ -162,7 +162,7 @@
                                true
 
                                [(#.Some x) (#.Some y)]
-                               (:: Eq<a> = x y)
+                               (:: Equivalence<a> = x y)
 
                                _
                                false)))
diff --git a/stdlib/source/lux/data/coll/bits.lux b/stdlib/source/lux/data/coll/bits.lux
index 950aadd0f..94d3398a0 100644
--- a/stdlib/source/lux/data/coll/bits.lux
+++ b/stdlib/source/lux/data/coll/bits.lux
@@ -1,6 +1,6 @@
 (.module:
   [lux #- not and or]
-  (lux (control [equality #+ Eq]
+  (lux (control [equivalence #+ Equivalence]
                 pipe)
        (data [maybe]
              [bit]
@@ -151,7 +151,7 @@
   [xor bit.xor]
   )
 
-(struct: #export _ (Eq Bits)
+(struct: #export _ (Equivalence Bits)
   (def: (= reference sample)
     (let [size (n/max (array.size reference)
                       (array.size sample))]
diff --git a/stdlib/source/lux/data/coll/dictionary/ordered.lux b/stdlib/source/lux/data/coll/dictionary/ordered.lux
index aec44d943..6fbcb5a42 100644
--- a/stdlib/source/lux/data/coll/dictionary/ordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/ordered.lux
@@ -1,7 +1,7 @@
 (.module:
   lux
   (lux (control [monad #+ do Monad]
-                equality
+                equivalence
                 [order #+ Order])
        (data (coll [list "L/" Monad<List> Monoid<List> Fold<List>])
              ["p" product]
@@ -551,9 +551,9 @@
   [values  v     (get@ #value node')]
   )
 
-(struct: #export (Eq<Dict> Eq<v>) (All [k v] (-> (Eq v) (Eq (Dict k v))))
+(struct: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
   (def: (= reference sample)
-    (let [Eq<k> (:: sample eq)]
+    (let [Equivalence<k> (:: sample eq)]
       (loop [entriesR (entries reference)
              entriesS (entries sample)]
         (case [entriesR entriesS]
@@ -561,8 +561,8 @@
           true
 
           [(#.Cons [keyR valueR] entriesR') (#.Cons [keyS valueS] entriesS')]
-          (and (:: Eq<k> = keyR keyS)
-               (:: Eq<v> = valueR valueS)
+          (and (:: Equivalence<k> = keyR keyS)
+               (:: Equivalence<v> = valueR valueS)
                (recur entriesR' entriesS'))
 
           _
diff --git a/stdlib/source/lux/data/coll/dictionary/plist.lux b/stdlib/source/lux/data/coll/dictionary/plist.lux
index e9e08107a..c483a3287 100644
--- a/stdlib/source/lux/data/coll/dictionary/plist.lux
+++ b/stdlib/source/lux/data/coll/dictionary/plist.lux
@@ -1,6 +1,6 @@
 (.module:
   lux
-  (lux (data [text "text/" Eq<Text>])))
+  (lux (data [text "text/" Equivalence<Text>])))
 
 (type: #export (PList a)
   (List [Text a]))
diff --git a/stdlib/source/lux/data/coll/dictionary/unordered.lux b/stdlib/source/lux/data/coll/dictionary/unordered.lux
index 12c58a2fd..bb6d12b24 100644
--- a/stdlib/source/lux/data/coll/dictionary/unordered.lux
+++ b/stdlib/source/lux/data/coll/dictionary/unordered.lux
@@ -1,7 +1,7 @@
 (.module:
   lux
   (lux (control hash
-                [equality #+ Eq])
+                [equivalence #+ Equivalence])
        (data [maybe]
              (coll [list "list/" Fold<List> Functor<List> Monoid<List>]
                    [array "array/" Functor<Array> Fold<Array>])
@@ -671,14 +671,14 @@
                keys)))
 
 ## [Structures]
-(struct: #export (Eq<Dict> Eq<v>) (All [k v] (-> (Eq v) (Eq (Dict k v))))
+(struct: #export (Equivalence<Dict> Equivalence<v>) (All [k v] (-> (Equivalence v) (Equivalence (Dict k v))))
   (def: (= test subject)
     (and (n/= (size test)
               (size subject))
          (list.every? (function (_ k)
                         (case [(get k test) (get k subject)]
                           [(#.Some tk) (#.Some sk)]
-                          (:: Eq<v> = tk sk)
+                          (:: Equivalence<v> = tk sk)
 
                           _
                           false))
diff --git a/stdlib/source/lux/data/coll/list.lux b/stdlib/source/lux/data/coll/list.lux
index 7f5a71994..4049fce8e 100644
--- a/stdlib/source/lux/data/coll/list.lux
+++ b/stdlib/source/lux/data/coll/list.lux
@@ -4,7 +4,7 @@
                 [functor #+ Functor]
                 [apply #+ Apply]
                 [monad #+ do Monad]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 [fold])
        (data [number "nat/" Codec<Text,Nat>]
              bool
@@ -265,15 +265,15 @@
       (nth (dec i) xs'))))
 
 ## [Structures]
-(struct: #export (Eq<List> Eq<a>)
-  (All [a] (-> (Eq a) (Eq (List a))))
+(struct: #export (Equivalence<List> Equivalence<a>)
+  (All [a] (-> (Equivalence a) (Equivalence (List a))))
   (def: (= xs ys)
     (case [xs ys]
       [#.Nil #.Nil]
       true
 
       [(#.Cons x xs') (#.Cons y ys')]
-      (and (:: Eq<a> = x y)
+      (and (:: Equivalence<a> = x y)
            (= xs' ys'))
 
       [_ _]
@@ -357,7 +357,7 @@
     _     false))
 
 (def: #export (member? eq xs x)
-  (All [a] (-> (Eq a) (List a) a Bool))
+  (All [a] (-> (Equivalence a) (List a) a Bool))
   (case xs
     #.Nil           false
     (#.Cons x' xs') (or (:: eq = x x')
diff --git a/stdlib/source/lux/data/coll/queue.lux b/stdlib/source/lux/data/coll/queue.lux
index 3a39a3e41..490351d29 100644
--- a/stdlib/source/lux/data/coll/queue.lux
+++ b/stdlib/source/lux/data/coll/queue.lux
@@ -1,6 +1,6 @@
 (.module:
   lux
-  (lux (control [equality #+ Eq]
+  (lux (control [equivalence #+ Equivalence]
                 ["F" functor])
        (data (coll [list "L/" Monoid<List> Functor<List>]))))
 
@@ -37,11 +37,11 @@
   (All [a] (-> (Queue a) Bool))
   (|>> (get@ #front) list.empty?))
 
-(def: #export (member? Eq<a> queue member)
-  (All [a] (-> (Eq a) (Queue a) a Bool))
+(def: #export (member? Equivalence<a> queue member)
+  (All [a] (-> (Equivalence a) (Queue a) a Bool))
   (let [(^slots [#front #rear]) queue]
-    (or (list.member? Eq<a> front member)
-        (list.member? Eq<a> rear member))))
+    (or (list.member? Equivalence<a> front member)
+        (list.member? Equivalence<a> rear member))))
 
 (def: #export (pop queue)
   (All [a] (-> (Queue a) (Queue a)))
@@ -67,10 +67,10 @@
     _
     (update@ #rear (|>> (#.Cons val)) queue)))
 
-(struct: #export (Eq<Queue> Eq<a>)
-  (All [a] (-> (Eq a) (Eq (Queue a))))
+(struct: #export (Equivalence<Queue> Equivalence<a>)
+  (All [a] (-> (Equivalence a) (Equivalence (Queue a))))
   (def: (= qx qy)
-    (:: (list.Eq<List> Eq<a>) = (to-list qx) (to-list qy))))
+    (:: (list.Equivalence<List> Equivalence<a>) = (to-list qx) (to-list qy))))
 
 (struct: #export _ (F.Functor Queue)
   (def: (map f fa)
diff --git a/stdlib/source/lux/data/coll/queue/priority.lux b/stdlib/source/lux/data/coll/queue/priority.lux
index a1e765fc3..443a54908 100644
--- a/stdlib/source/lux/data/coll/queue/priority.lux
+++ b/stdlib/source/lux/data/coll/queue/priority.lux
@@ -1,6 +1,6 @@
 (.module:
   lux
-  (lux (control [equality #+ Eq]
+  (lux (control [equivalence #+ Equivalence]
                 [monad #+ do Monad])
        (data (coll (tree [finger #+ Tree]))
              [number "nat/" Interval<Nat>]
@@ -39,8 +39,8 @@
         (#finger.Branch _ left right)
         (n/+ (recur left) (recur right))))))
 
-(def: #export (member? Eq<a> queue member)
-  (All [a] (-> (Eq a) (Queue a) a Bool))
+(def: #export (member? Equivalence<a> queue member)
+  (All [a] (-> (Equivalence a) (Queue a) a Bool))
   (case queue
     #.None
     false
@@ -49,7 +49,7 @@
     (loop [node (get@ #finger.node fingers)]
       (case node
         (#finger.Leaf _ reference)
-        (:: Eq<a> = reference member)
+        (:: Equivalence<a> = reference member)
 
         (#finger.Branch _ left right)
         (or (recur left)
diff --git a/stdlib/source/lux/data/coll/row.lux b/stdlib/source/lux/data/coll/row.lux
index 0b258a2ec..2c50120ec 100644
--- a/stdlib/source/lux/data/coll/row.lux
+++ b/stdlib/source/lux/data/coll/row.lux
@@ -3,7 +3,7 @@
   (lux (control [functor #+ Functor]
                 [apply #+ Apply]
                 [monad #+ do Monad]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 monoid
                 fold
                 ["p" parser])
@@ -328,9 +328,9 @@
              empty
              list))
 
-(def: #export (member? a/Eq vec val)
-  (All [a] (-> (Eq a) (Row a) a Bool))
-  (list.member? a/Eq (to-list vec) val))
+(def: #export (member? a/Equivalence vec val)
+  (All [a] (-> (Equivalence a) (Row a) a Bool))
+  (list.member? a/Equivalence (to-list vec) val))
 
 (def: #export empty?
   (All [a] (-> (Row a) Bool))
@@ -343,22 +343,22 @@
   (wrap (list (` (from-list (list (~+ elems)))))))
 
 ## [Structures]
-(struct: #export (Eq<Node> Eq<a>) (All [a] (-> (Eq a) (Eq (Node a))))
+(struct: #export (Equivalence<Node> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Node a))))
   (def: (= v1 v2)
     (case [v1 v2]
       [(#Base b1) (#Base b2)]
-      (:: (array.Eq<Array> Eq<a>) = b1 b2)
+      (:: (array.Equivalence<Array> Equivalence<a>) = b1 b2)
       
       [(#Hierarchy h1) (#Hierarchy h2)]
-      (:: (array.Eq<Array> (Eq<Node> Eq<a>)) = h1 h2)
+      (:: (array.Equivalence<Array> (Equivalence<Node> Equivalence<a>)) = h1 h2)
 
       _
       false)))
 
-(struct: #export (Eq<Row> Eq<a>) (All [a] (-> (Eq a) (Eq (Row a))))
+(struct: #export (Equivalence<Row> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Row a))))
   (def: (= v1 v2)
     (and (n/= (get@ #size v1) (get@ #size v2))
-         (let [(^open "Node/") (Eq<Node> Eq<a>)]
+         (let [(^open "Node/") (Equivalence<Node> Equivalence<a>)]
            (and (Node/= (#Base (get@ #tail v1))
                         (#Base (get@ #tail v2)))
                 (Node/= (#Hierarchy (get@ #root v1))
diff --git a/stdlib/source/lux/data/coll/set/ordered.lux b/stdlib/source/lux/data/coll/set/ordered.lux
index 5b7524a8a..0862d62c2 100644
--- a/stdlib/source/lux/data/coll/set/ordered.lux
+++ b/stdlib/source/lux/data/coll/set/ordered.lux
@@ -1,7 +1,7 @@
 (.module:
   lux
   (lux (control [monad #+ do Monad]
-                equality
+                equivalence
                 [order #+ Order])
        (data (coll [list "L/" Monad<List> Monoid<List> Fold<List>]
                    (dictionary ["d" ordered]))
@@ -80,7 +80,7 @@
   (All [a] (-> (Set a) (Set a) Bool))
   (sub? super sub))
 
-(struct: #export Eq<Set> (All [a] (Eq (Set a)))
+(struct: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
   (def: (= reference sample)
-    (:: (list.Eq<List> (:: sample eq))
+    (:: (list.Equivalence<List> (:: sample eq))
         = (to-list reference) (to-list sample))))
diff --git a/stdlib/source/lux/data/coll/set/unordered.lux b/stdlib/source/lux/data/coll/set/unordered.lux
index e977f35e5..4fcc0c1cc 100644
--- a/stdlib/source/lux/data/coll/set/unordered.lux
+++ b/stdlib/source/lux/data/coll/set/unordered.lux
@@ -1,6 +1,6 @@
 (.module:
   lux
-  (lux (control [equality #+ Eq]
+  (lux (control [equivalence #+ Equivalence]
                 [hash #*])
        (data (coll (dictionary ["dict" unordered #+ Dict])
                    [list "list/" Fold<List> Functor<List>]))))
@@ -63,12 +63,12 @@
   (sub? super sub))
 
 ## [Structures]
-(struct: #export Eq<Set> (All [a] (Eq (Set a)))
+(struct: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
   (def: (= (^@ test [Hash<a> _]) subject)
-    (:: (list.Eq<List> (get@ #hash.eq Hash<a>)) = (to-list test) (to-list subject))))
+    (:: (list.Equivalence<List> (get@ #hash.eq Hash<a>)) = (to-list test) (to-list subject))))
 
 (struct: #export Hash<Set> (All [a] (Hash (Set a)))
-  (def: eq Eq<Set>)
+  (def: eq Equivalence<Set>)
   
   (def: (hash (^@ set [Hash<a> _]))
     (list/fold (function (_ elem acc) (n/+ (:: Hash<a> hash elem) acc))
diff --git a/stdlib/source/lux/data/coll/tree/rose.lux b/stdlib/source/lux/data/coll/tree/rose.lux
index 28ca96d41..8171dcdaa 100644
--- a/stdlib/source/lux/data/coll/tree/rose.lux
+++ b/stdlib/source/lux/data/coll/tree/rose.lux
@@ -2,7 +2,7 @@
   lux
   (lux (control functor
                 [monad #+ do Monad]
-                equality
+                equivalence
                 ["p" parser]
                 fold)
        (data (coll [list "L/" Monad<List> Fold<List>]))
@@ -54,10 +54,10 @@
                           #children (list (~+ (L/map recur children)))})))))))
 
 ## [Structs]
-(struct: #export (Eq<Tree> Eq<a>) (All [a] (-> (Eq a) (Eq (Tree a))))
+(struct: #export (Equivalence<Tree> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Tree a))))
   (def: (= tx ty)
-    (and (:: Eq<a> = (get@ #value tx) (get@ #value ty))
-         (:: (list.Eq<List> (Eq<Tree> Eq<a>)) = (get@ #children tx) (get@ #children ty)))))
+    (and (:: Equivalence<a> = (get@ #value tx) (get@ #value ty))
+         (:: (list.Equivalence<List> (Equivalence<Tree> Equivalence<a>)) = (get@ #children tx) (get@ #children ty)))))
 
 (struct: #export _ (Functor Tree)
   (def: (map f fa)
diff --git a/stdlib/source/lux/data/color.lux b/stdlib/source/lux/data/color.lux
index 241347859..67c9c3388 100644
--- a/stdlib/source/lux/data/color.lux
+++ b/stdlib/source/lux/data/color.lux
@@ -1,6 +1,6 @@
 (.module:
   lux
-  (lux (control ["eq" equality])
+  (lux (control ["eq" equivalence])
        (data (coll [list "L/" Functor<List>]))
        [math]
        (type abstract)))
@@ -33,7 +33,7 @@
     (-> Color [Nat Nat Nat])
     (|>> :representation))
 
-  (struct: #export _ (eq.Eq Color)
+  (struct: #export _ (eq.Equivalence Color)
     (def: (= reference sample)
       (let [[rr rg rb] (:representation reference)
             [sr sg sb] (:representation sample)]
diff --git a/stdlib/source/lux/data/format/json.lux b/stdlib/source/lux/data/format/json.lux
index a5c81ad6b..984fbb1aa 100644
--- a/stdlib/source/lux/data/format/json.lux
+++ b/stdlib/source/lux/data/format/json.lux
@@ -3,11 +3,11 @@
                   For more information, please see: http://www.json.org/"}
   [lux #- Array]
   (lux (control [monad #+ do Monad]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 codec
                 ["p" parser "parser/" Monad<Parser>])
        (data [bool]
-             [text "text/" Eq<Text> Monoid<Text>]
+             [text "text/" Equivalence<Text> Monoid<Text>]
              (text ["l" lexer])
              [number "frac/" Codec<Text,Frac> "nat/" Codec<Text,Nat>]
              [maybe]
@@ -147,7 +147,7 @@
   [get-object  #Object  Object  "objects"]
   )
 
-(struct: #export _ (Eq JSON)
+(struct: #export _ (Equivalence JSON)
   (def: (= x y)
     (case [x y]
       [#Null #Null]
@@ -156,9 +156,9 @@
       (^template [<tag> <struct>]
         [(<tag> x') (<tag> y')]
         (:: <struct> = x' y'))
-      ([#Boolean bool.Eq<Bool>]
-       [#Number  number.Eq<Frac>]
-       [#String  text.Eq<Text>])
+      ([#Boolean bool.Equivalence<Bool>]
+       [#Number  number.Equivalence<Frac>]
+       [#String  text.Equivalence<Text>])
 
       [(#Array xs) (#Array ys)]
       (and (n/= (row.size xs) (row.size ys))
@@ -268,9 +268,9 @@
          _
          (fail ($_ text/compose "JSON value is not a " <desc> ".")))))]
 
-  [boolean? boolean! Bool bool.Eq<Bool>   (:: bool.Codec<Text,Bool> encode)   #Boolean "boolean" id]
-  [number?  number!  Frac number.Eq<Frac> (:: number.Codec<Text,Frac> encode) #Number  "number"  id]
-  [string?  string!  Text text.Eq<Text>   text.encode                         #String  "string"  id]
+  [boolean? boolean! Bool bool.Equivalence<Bool>   (:: bool.Codec<Text,Bool> encode)   #Boolean "boolean" id]
+  [number?  number!  Frac number.Equivalence<Frac> (:: number.Codec<Text,Frac> encode) #Number  "number"  id]
+  [string?  string!  Text text.Equivalence<Text>   text.encode                         #String  "string"  id]
   )
 
 (def: #export (nullable parser)
diff --git a/stdlib/source/lux/data/format/xml.lux b/stdlib/source/lux/data/format/xml.lux
index a725263af..7d1614fca 100644
--- a/stdlib/source/lux/data/format/xml.lux
+++ b/stdlib/source/lux/data/format/xml.lux
@@ -1,17 +1,17 @@
 (.module: {#.doc "Functionality for reading, generating and processing values in the XML format."}
   lux
   (lux (control monad
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 codec
                 ["p" parser "p/" Monad<Parser>]
                 ["ex" exception #+ exception:])
-       (data [text "text/" Eq<Text> Monoid<Text>]
+       (data [text "text/" Equivalence<Text> Monoid<Text>]
              (text ["l" lexer])
              [number]
              ["E" error]
              [product]
              [maybe "m/" Monad<Maybe>]
-             [ident "ident/" Eq<Ident> Codec<Text,Ident>]
+             [ident "ident/" Equivalence<Ident> Codec<Text,Ident>]
              (coll [list "list/" Monad<List>]
                    (dictionary ["d" unordered])))))
 
@@ -224,7 +224,7 @@
   (def: encode write)
   (def: decode read))
 
-(struct: #export _ (Eq XML)
+(struct: #export _ (Equivalence XML)
   (def: (= reference sample)
     (case [reference sample]
       [(#Text reference/value) (#Text sample/value)]
@@ -233,7 +233,7 @@
       [(#Node reference/tag reference/attrs reference/children)
        (#Node sample/tag sample/attrs sample/children)]
       (and (ident/= reference/tag sample/tag)
-           (:: (d.Eq<Dict> text.Eq<Text>) = reference/attrs sample/attrs)
+           (:: (d.Equivalence<Dict> text.Equivalence<Text>) = reference/attrs sample/attrs)
            (n/= (list.size reference/children)
                 (list.size sample/children))
            (|> (list.zip2 reference/children sample/children)
diff --git a/stdlib/source/lux/data/ident.lux b/stdlib/source/lux/data/ident.lux
index 867f96d8b..cb0b35b1f 100644
--- a/stdlib/source/lux/data/ident.lux
+++ b/stdlib/source/lux/data/ident.lux
@@ -1,9 +1,9 @@
 (.module:
   lux
-  (lux (control [equality #+ Eq]
+  (lux (control [equivalence #+ Equivalence]
                 [codec #+ Codec]
                 hash)
-       (data [text "text/" Monoid<Text> Eq<Text>])))
+       (data [text "text/" Monoid<Text> Equivalence<Text>])))
 
 ## [Types]
 ## (type: Ident
@@ -20,7 +20,7 @@
   )
 
 ## [Structures]
-(struct: #export _ (Eq Ident)
+(struct: #export _ (Equivalence Ident)
   (def: (= [xmodule xname] [ymodule yname])
     (and (text/= xmodule ymodule)
          (text/= xname yname))))
@@ -45,7 +45,7 @@
         (#.Left (text/compose "Invalid format for Ident: " input))))))
 
 (struct: #export _ (Hash Ident)
-  (def: eq Eq<Ident>)
+  (def: eq Equivalence<Ident>)
   
   (def: (hash [module name])
     (let [(^open) text.Hash<Text>]
diff --git a/stdlib/source/lux/data/maybe.lux b/stdlib/source/lux/data/maybe.lux
index 6c5a7d02e..bfdb0fbe5 100644
--- a/stdlib/source/lux/data/maybe.lux
+++ b/stdlib/source/lux/data/maybe.lux
@@ -4,7 +4,7 @@
                 ["F" functor]
                 ["A" apply]
                 [monad #+ do Monad]
-                [equality #+ Eq])))
+                [equivalence #+ Equivalence])))
 
 ## [Types]
 ## (type: (Maybe a)
@@ -47,14 +47,14 @@
       #.None      #.None
       (#.Some xs) xs)))
 
-(struct: #export (Eq<Maybe> Eq<a>) (All [a] (-> (Eq a) (Eq (Maybe a))))
+(struct: #export (Equivalence<Maybe> Equivalence<a>) (All [a] (-> (Equivalence a) (Equivalence (Maybe a))))
   (def: (= mx my)
     (case [mx my]
       [#.None #.None]
       true
 
       [(#.Some x) (#.Some y)]
-      (:: Eq<a> = x y)
+      (:: Equivalence<a> = x y)
       
       _
       false)))
diff --git a/stdlib/source/lux/data/number.lux b/stdlib/source/lux/data/number.lux
index 8c9e663cb..637d0d0ba 100644
--- a/stdlib/source/lux/data/number.lux
+++ b/stdlib/source/lux/data/number.lux
@@ -2,7 +2,7 @@
   lux
   (lux (control number
                 [monoid #+ Monoid]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 hash
                 [order]
                 enum
@@ -14,7 +14,7 @@
 
 ## [Structures]
 (do-template [<type> <test>]
-  [(struct: #export _ (Eq <type>)
+  [(struct: #export _ (Equivalence <type>)
      (def: = <test>))]
 
   [ Nat n/=]
@@ -31,10 +31,10 @@
      (def: > <gt>)
      (def: >= <gte>))]
 
-  [ Nat Eq<Nat>  n/< n/<= n/> n/>=]
-  [ Int Eq<Int>  i/< i/<= i/> i/>=]
-  [Rev  Eq<Rev>  r/< r/<= r/> r/>=]
-  [Frac Eq<Frac> f/< f/<= f/> f/>=]
+  [ Nat Equivalence<Nat>  n/< n/<= n/> n/>=]
+  [ Int Equivalence<Int>  i/< i/<= i/> i/>=]
+  [Rev  Equivalence<Rev>  r/< r/<= r/> r/>=]
+  [Frac Equivalence<Frac> f/< f/<= f/> f/>=]
   )
 
 (struct: #export _ (Number Nat)
@@ -995,18 +995,18 @@
 
 ## [Hash]
 (struct: #export _ (Hash Nat)
-  (def: eq Eq<Nat>)
+  (def: eq Equivalence<Nat>)
   (def: hash id))
 
 (struct: #export _ (Hash Int)
-  (def: eq Eq<Int>)
+  (def: eq Equivalence<Int>)
   (def: hash .nat))
 
 (struct: #export _ (Hash Frac)
-  (def: eq Eq<Frac>)
+  (def: eq Equivalence<Frac>)
   
   (def: hash frac-to-bits))
 
 (struct: #export _ (Hash Rev)
-  (def: eq Eq<Rev>)
+  (def: eq Equivalence<Rev>)
   (def: hash (|>> (:coerce Nat))))
diff --git a/stdlib/source/lux/data/number/complex.lux b/stdlib/source/lux/data/number/complex.lux
index 792d2ce53..a7e535f08 100644
--- a/stdlib/source/lux/data/number/complex.lux
+++ b/stdlib/source/lux/data/number/complex.lux
@@ -1,7 +1,7 @@
 (.module: {#.doc "Complex arithmetic."}
   lux
   (lux [math]
-       (control [equality #+ Eq]
+       (control [equivalence #+ Equivalence]
                 number
                 codec
                 ["M" monad #+ do Monad]
@@ -56,7 +56,7 @@
   [- f/-]
   )
 
-(struct: #export _ (Eq Complex)
+(struct: #export _ (Equivalence Complex)
   (def: = ..=))
 
 (def: #export negate
diff --git a/stdlib/source/lux/data/number/ratio.lux b/stdlib/source/lux/data/number/ratio.lux
index 6d241064a..c96c66882 100644
--- a/stdlib/source/lux/data/number/ratio.lux
+++ b/stdlib/source/lux/data/number/ratio.lux
@@ -1,7 +1,7 @@
 (.module: {#.doc "Rational arithmetic."}
   lux
   (lux [math]
-       (control [equality #+ Eq]
+       (control [equivalence #+ Equivalence]
                 [order]
                 number
                 codec
@@ -100,11 +100,11 @@
   [max >]
   )
 
-(struct: #export _ (Eq Ratio)
+(struct: #export _ (Equivalence Ratio)
   (def: = ..=))
 
 (struct: #export _ (order.Order Ratio)
-  (def: eq Eq<Ratio>)
+  (def: eq Equivalence<Ratio>)
   (def: < ..<)
   (def: <= ..<=)
   (def: > ..>)
diff --git a/stdlib/source/lux/data/text.lux b/stdlib/source/lux/data/text.lux
index 58826e2c9..04af675c4 100644
--- a/stdlib/source/lux/data/text.lux
+++ b/stdlib/source/lux/data/text.lux
@@ -1,7 +1,7 @@
 (.module:
   lux
   (lux (control [monoid #+ Monoid]
-                [equality #+ Eq]
+                [equivalence #+ Equivalence]
                 [order]
                 [monad #+ do Monad]
                 [codec #+ Codec]
@@ -123,12 +123,12 @@
   (split-all-with "\n"))
 
 ## [Structures]
-(struct: #export _ (Eq Text)
+(struct: #export _ (Equivalence Text)
   (def: (= test subject)
     ("lux text =" subject test)))
 
 (struct: #export _ (order.Order Text)
-  (def: eq Eq<Text>)
+  (def: eq Equivalence<Text>)
 
   (def: (< test subject)
     ("lux text <" subject test))
@@ -167,7 +167,7 @@
     ($_ text/compose "\"" escaped "\"")))
 
 (struct: #export _ (Hash Text)
-  (def: eq Eq<Text>)
+  (def: eq Equivalence<Text>)
   
   (def: (hash input)
     ("lux text hash" input)))