feat(hashset): add intersection and difference methods to hashset

Author: Asterless

immut/hashset/HAMT.mbt

@@ -192,6 +192,56 @@ pub fn union[K : Eq + Hash](self : T[K], other : T[K]) -> T[K] {
   }
 }
 
+///|
+/// Intersect two hashsets
+pub fn intersection[K : Eq + Hash](self : T[K], other : T[K]) -> T[K] {
+  match (self, other) {
+    (_, Empty) => Empty
+    (Empty, _) => Empty
+    (Leaf(k), _) => if other.contains(k) { Leaf(k) } else { Empty }
+    (_, Leaf(k)) => if self.contains(k) { Leaf(k) } else { Empty }
+    (Branch(sa1), Branch(sa2)) => {
+      let res = sa1.intersection(sa2, fn(m1, m2) { m1.intersection(m2) })
+      if res.size() == 0 {
+        Empty
+      } else {
+        Branch(res)
+      }
+    }
+    (_, _) =>
+      self
+      .iter()
+      .fold(init=Empty, fn(m, k) {
+        if other.contains(k) {
+          m.add(k)
+        } else {
+          m
+        }
+      })
+  }
+}
+
+///|
+/// Difference of two hashsets: elements in `self` but not in `other`
+pub fn difference[K : Eq + Hash](self : T[K], other : T[K]) -> T[K] {
+  match (self, other) {
+    (Empty, _) => Empty
+    (_, Empty) => self
+    (Leaf(k), _) => if other.contains(k) { Empty } else { Leaf(k) }
+    (Branch(sa1), Branch(sa2)) => Branch(sa1.difference(sa2))
+    (_, _) =>
+      self
+      .iter()
+      .fold(init=Empty, fn(m, k) {
+        if other.contains(k) {
+          m
+        } else {
+          m.add(k)
+        }
+      })
+  }
+}
+
 ///|
 /// Returns true if the hash set is empty.
 pub fn is_empty[A](self : T[A]) -> Bool {

immut/hashset/HAMT_test.mbt

@@ -217,3 +217,43 @@ test "union 2 hashsets" {
   let set4 = @hashset.of([1, 2, 3, 4, 5])
   inspect!(set3 == set4, content="true")
 }
+
+///|
+test "@hashset.intersection with overlapping sets" {
+  let set1 = @hashset.of([1, 2, 3, 4])
+  let set2 = @hashset.of([3, 4, 5, 6])
+  let result = set1.intersection(set2)
+  inspect!(result, content="@immut/hashset.of([3, 4])")
+}
+
+///|
+test "@hashset.intersection with disjoint sets" {
+  let set1 = @hashset.of([1, 2])
+  let set2 = @hashset.of([3, 4])
+  let result = set1.intersection(set2)
+  inspect!(result.is_empty(), content="true")
+}
+
+///|
+test "@hashset.intersection with one empty set" {
+  let set1 = @hashset.of([1, 2, 3])
+  let set2 = @hashset.new()
+  let result = set1.intersection(set2)
+  inspect!(result.is_empty(), content="true")
+}
+
+///|
+test "@hashset.intersection with identical sets" {
+  let set1 = @hashset.of([1, 2, 3])
+  let set2 = @hashset.of([1, 2, 3])
+  let result = set1.intersection(set2)
+  inspect!(result == set1, content="true")
+}
+
+///|
+test "@hashset.intersection with subset" {
+  let set1 = @hashset.of([1, 2, 3, 4])
+  let set2 = @hashset.of([2, 3])
+  let result = set1.intersection(set2)
+  inspect!(result == @hashset.of([2, 3]), content="true")
+}

immut/hashset/hashset.mbti

@@ -29,6 +29,10 @@ fn size[A](T[A]) -> Int
 
 fn union[K : Eq + Hash](T[K], T[K]) -> T[K]
 
+fn intersection[K : Eq + Hash](T[K], T[K]) -> T[K]
+
+fn difference[K : Eq + Hash](T[K], T[K]) -> T[K]
+
 // Types and methods
 type T[A]
 impl T {
@@ -40,6 +44,8 @@ impl T {
   remove[A : Eq + Hash](Self[A], A) -> Self[A]
   size[A](Self[A]) -> Int
   union[K : Eq + Hash](Self[K], Self[K]) -> Self[K]
+  intersection[K : Eq + Hash](Self[K], Self[K]) -> Self[K]
+  difference[K : Eq + Hash](Self[K], Self[K]) -> Self[K]
 }
 impl[A : Eq] Eq for T[A]
 impl[A : Hash] Hash for T[A]