1 files changed, 66 insertions, 61 deletions
diff --git a/stdlib/source/lux/data/coll/set/unordered.lux b/stdlib/source/lux/data/coll/set/unordered.lux
index 6f0007412..1d9942206 100644
--- a/stdlib/source/lux/data/coll/set/unordered.lux
+++ b/stdlib/source/lux/data/coll/set/unordered.lux
@@ -1,76 +1,81 @@
 (.module:
   lux
   (lux (control [equivalence #+ Equivalence]
-                [hash #*])
+                [hash #+ Hash])
        (data (coll (dictionary ["dict" unordered #+ Dict])
-                   [list "list/" Fold<List> Functor<List>]))))
+                   [list "list/" Fold<List>]))
+       (type abstract)))
 
-## [Types]
-(type: #export (Set a)
-  (Dict a a))
-
-## [Values]
-(def: #export (new Hash<a>)
-  (All [a] (-> (Hash a) (Set a)))
-  (dict.new Hash<a>))
-
-(def: #export (add elem set)
-  (All [a] (-> a (Set a) (Set a)))
-  (dict.put elem elem set))
-
-(def: #export (remove elem set)
-  (All [a] (-> a (Set a) (Set a)))
-  (dict.remove elem set))
-
-(def: #export (member? set elem)
-  (All [a] (-> (Set a) a Bool))
-  (dict.contains? elem set))
-
-(def: #export to-list
-  (All [a] (-> (Set a) (List a)))
-  dict.keys)
+(abstract: #export (Set a)
+  {}
+  
+  (Dict a a)
+
+  (def: #export new
+    (All [a] (-> (Hash a) (Set a)))
+    (|>> dict.new :abstraction))
+
+  (def: #export size
+    (All [a] (-> (Set a) Nat))
+    (|>> :representation dict.size))
+
+  (def: #export (add elem set)
+    (All [a] (-> a (Set a) (Set a)))
+    (|> set :representation (dict.put elem elem) :abstraction))
+
+  (def: #export (remove elem set)
+    (All [a] (-> a (Set a) (Set a)))
+    (|> set :representation (dict.remove elem) :abstraction))
+
+  (def: #export (member? set elem)
+    (All [a] (-> (Set a) a Bool))
+    (|> set :representation (dict.contains? elem)))
+
+  (def: #export to-list
+    (All [a] (-> (Set a) (List a)))
+    (|>> :representation dict.keys))
+
+  (def: #export (union xs yx)
+    (All [a] (-> (Set a) (Set a) (Set a)))
+    (:abstraction (dict.merge (:representation xs) (:representation yx))))
+
+  (def: #export (difference sub base)
+    (All [a] (-> (Set a) (Set a) (Set a)))
+    (list/fold ..remove base (..to-list sub)))
+
+  (def: #export (intersection filter base)
+    (All [a] (-> (Set a) (Set a) (Set a)))
+    (:abstraction (dict.select (dict.keys (:representation filter))
+                               (:representation base))))
+
+  (structure: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
+    (def: (= reference sample)
+      (let [[Hash<a> _] (:representation reference)]
+        (:: (list.Equivalence<List> (get@ #hash.eq Hash<a>)) =
+            (..to-list reference) (..to-list sample)))))
+
+  (structure: #export Hash<Set> (All [a] (Hash (Set a)))
+    (def: eq ..Equivalence<Set>)
+    
+    (def: (hash set)
+      (let [[Hash<a> _] (:representation set)]
+        (list/fold (function (_ elem acc) (n/+ (:: Hash<a> hash elem) acc))
+                   +0
+                   (..to-list set)))))
+  )
+
+(def: #export empty?
+  (All [a] (-> (Set a) Bool))
+  (|>> ..size (n/= +0)))
 
 (def: #export (from-list Hash<a> xs)
   (All [a] (-> (Hash a) (List a) (Set a)))
-  (list/fold add (new Hash<a>) xs))
-
-(def: #export (union xs yx)
-  (All [a] (-> (Set a) (Set a) (Set a)))
-  (dict.merge xs yx))
-
-(def: #export (difference sub base)
-  (All [a] (-> (Set a) (Set a) (Set a)))
-  (list/fold remove base (to-list sub)))
-
-(def: #export (intersection filter base)
-  (All [a] (-> (Set a) (Set a) (Set a)))
-  (dict.select (dict.keys filter) base))
-
-(def: #export (size set)
-  (All [a] (-> (Set a) Nat))
-  (dict.size set))
-
-(def: #export (empty? set)
-  (All [a] (-> (Set a) Bool))
-  (n/= +0 (dict.size set)))
+  (list/fold ..add (..new Hash<a>) xs))
 
 (def: #export (sub? super sub)
   (All [a] (-> (Set a) (Set a) Bool))
-  (list.every? (member? super) (to-list sub)))
+  (list.every? (..member? super) (..to-list sub)))
 
 (def: #export (super? sub super)
   (All [a] (-> (Set a) (Set a) Bool))
   (sub? super sub))
-
-## [Structures]
-(structure: #export Equivalence<Set> (All [a] (Equivalence (Set a)))
-  (def: (= (^@ test [Hash<a> _]) subject)
-    (:: (list.Equivalence<List> (get@ #hash.eq Hash<a>)) = (to-list test) (to-list subject))))
-
-(structure: #export Hash<Set> (All [a] (Hash (Set a)))
-  (def: eq Equivalence<Set>)
-  
-  (def: (hash (^@ set [Hash<a> _]))
-    (list/fold (function (_ elem acc) (n/+ (:: Hash<a> hash elem) acc))
-               +0
-               (to-list set))))