feat: add set operations to @immut/hash{map, set} and @internal/sparse_array (moonbitlang#2145)

* feat: add four new functions to HAMT and their tests

* fix(union_with): fix union_with for HAMT,now it can handle branch

* feat(sparse_array): add intersection and difference methods

* fix(HAMT): fix union_with, intersection, intersection_with and difference methods, now they can handle branchs

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

* commit other files

* feat: add four new functions to HAMT and their tests

* fix(union_with): fix union_with for HAMT,now it can handle branch

* feat(sparse_array): add intersection and difference methods

* fix(HAMT): fix union_with, intersection, intersection_with and difference methods, now they can handle branchs

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

* style: change the position of some function declarations

* fix: fix formatting of the code

* feat: Update the function declarations of hash tables and sparse arrays

* refactor:update mbti

* refactor: update hashmap and hashset function signatures to include type prefix

---------

Co-authored-by: 东灯 <[email protected]>

Author: Asterless

immut/hashmap/HAMT.mbt

@@ -311,7 +311,7 @@ pub fn[K, V] size(self : T[K, V]) -> Int {
 
 ///|
 /// Union two hashmaps
-pub fn[K : Eq + Hash, V] union(self : T[K, V], other : T[K, V]) -> T[K, V] {
+pub fn[K : Eq + Hash, V] T::union(self : T[K, V], other : T[K, V]) -> T[K, V] {
   match (self, other) {
     (_, Empty) => self
     (Empty, _) => other
@@ -331,7 +331,7 @@ pub fn[K : Eq + Hash, V] union(self : T[K, V], other : T[K, V]) -> T[K, V] {
 
 ///|
 /// Union two hashmaps with a function
-pub fn[K : Eq + Hash, V] union_with(
+pub fn[K : Eq + Hash, V] T::union_with(
   self : T[K, V],
   other : T[K, V],
   f : (K, V, V) -> V
@@ -365,7 +365,7 @@ pub fn[K : Eq + Hash, V] union_with(
 
 ///|
 /// Intersect two hashmaps
-pub fn[K : Eq + Hash, V] intersection(
+pub fn[K : Eq + Hash, V] T::intersection(
   self : T[K, V],
   other : T[K, V]
 ) -> T[K, V] {
@@ -399,7 +399,7 @@ pub fn[K : Eq + Hash, V] intersection(
 
 ///|
 /// Intersection two hashmaps with a function
-pub fn[K : Eq + Hash, V] intersection_with(
+pub fn[K : Eq + Hash, V] T::intersection_with(
   self : T[K, V],
   other : T[K, V],
   f : (K, V, V) -> V
@@ -433,7 +433,10 @@ pub fn[K : Eq + Hash, V] intersection_with(
 
 ///|
 /// Difference of two hashmaps: elements in `self` but not in `other`
-pub fn[K : Eq + Hash, V] difference(self : T[K, V], other : T[K, V]) -> T[K, V] {
+pub fn[K : Eq + Hash, V] T::difference(
+  self : T[K, V],
+  other : T[K, V]
+) -> T[K, V] {
   match (self, other) {
     (Empty, _) => Empty
     (_, Empty) => self

immut/hashmap/hashmap.mbti

@@ -60,14 +60,13 @@ fn[K, V] size(T[K, V]) -> Int
 
 fn[K, V] to_array(T[K, V]) -> Array[(K, V)]
 
-fn[K : Eq + Hash, V] union(T[K, V], T[K, V]) -> T[K, V]
-
 fn[K, V] values(T[K, V]) -> Iter[V]
 
 // Types and methods
 type T[K, V]
 fn[K : Eq + Hash, V] T::add(Self[K, V], K, V) -> Self[K, V]
 fn[K : Eq + Hash, V] T::contains(Self[K, V], K) -> Bool
+fn[K : Eq + Hash, V] T::difference(Self[K, V], Self[K, V]) -> Self[K, V]
 fn[K, V] T::each(Self[K, V], (K, V) -> Unit) -> Unit
 #deprecated
 fn[K, V] T::elems(Self[K, V]) -> Iter[V]
@@ -77,6 +76,8 @@ fn[K : Eq + Hash, V] T::find(Self[K, V], K) -> V?
 fn[K, V, A] T::fold(Self[K, V], init~ : A, (A, V) -> A) -> A
 fn[K, V, A] T::fold_with_key(Self[K, V], init~ : A, (A, K, V) -> A) -> A
 fn[K : Eq + Hash, V] T::get(Self[K, V], K) -> V?
+fn[K : Eq + Hash, V] T::intersection(Self[K, V], Self[K, V]) -> Self[K, V]
+fn[K : Eq + Hash, V] T::intersection_with(Self[K, V], Self[K, V], (K, V, V) -> V) -> Self[K, V]
 fn[K, V] T::iter(Self[K, V]) -> Iter[(K, V)]
 fn[K, V] T::iter2(Self[K, V]) -> Iter2[K, V]
 fn[K, V] T::keys(Self[K, V]) -> Iter[K]
@@ -88,6 +89,7 @@ fn[K : Eq + Hash, V] T::remove(Self[K, V], K) -> Self[K, V]
 fn[K, V] T::size(Self[K, V]) -> Int
 fn[K, V] T::to_array(Self[K, V]) -> Array[(K, V)]
 fn[K : Eq + Hash, V] T::union(Self[K, V], Self[K, V]) -> Self[K, V]
+fn[K : Eq + Hash, V] T::union_with(Self[K, V], Self[K, V], (K, V, V) -> V) -> Self[K, V]
 fn[K, V] T::values(Self[K, V]) -> Iter[V]
 impl[K : Eq + Hash, V : Eq] Eq for T[K, V]
 impl[K : Hash, V : Hash] Hash for T[K, V]

immut/hashset/HAMT.mbt

@@ -180,7 +180,7 @@ pub fn[A] size(self : T[A]) -> Int {
 
 ///|
 /// Union two hashsets
-pub fn[K : Eq + Hash] union(self : T[K], other : T[K]) -> T[K] {
+pub fn[K : Eq + Hash] T::union(self : T[K], other : T[K]) -> T[K] {
   match (self, other) {
     (_, Empty) => self
     (Empty, _) => other
@@ -194,7 +194,7 @@ pub fn[K : Eq + Hash] union(self : T[K], other : T[K]) -> T[K] {
 
 ///|
 /// Intersect two hashsets
-pub fn[K : Eq + Hash] intersection(self : T[K], other : T[K]) -> T[K] {
+pub fn[K : Eq + Hash] T::intersection(self : T[K], other : T[K]) -> T[K] {
   match (self, other) {
     (_, Empty) => Empty
     (Empty, _) => Empty
@@ -223,7 +223,7 @@ pub fn[K : Eq + Hash] intersection(self : T[K], other : T[K]) -> T[K] {
 
 ///|
 /// Difference of two hashsets: elements in `self` but not in `other`
-pub fn[K : Eq + Hash] difference(self : T[K], other : T[K]) -> T[K] {
+pub fn[K : Eq + Hash] T::difference(self : T[K], other : T[K]) -> T[K] {
   match (self, other) {
     (Empty, _) => Empty
     (_, Empty) => self

immut/hashset/hashset.mbti

@@ -31,13 +31,13 @@ fn[A : Eq + Hash] remove(T[A], A) -> T[A]
 
 fn[A] size(T[A]) -> Int
 
-fn[K : Eq + Hash] union(T[K], T[K]) -> T[K]
-
 // Types and methods
 type T[A]
 fn[A : Eq + Hash] T::add(Self[A], A) -> Self[A]
 fn[A : Eq + Hash] T::contains(Self[A], A) -> Bool
+fn[K : Eq + Hash] T::difference(Self[K], Self[K]) -> Self[K]
 fn[A] T::each(Self[A], (A) -> Unit) -> Unit
+fn[K : Eq + Hash] T::intersection(Self[K], Self[K]) -> Self[K]
 fn[A] T::is_empty(Self[A]) -> Bool
 fn[A] T::iter(Self[A]) -> Iter[A]
 fn[A : Eq + Hash] T::remove(Self[A], A) -> Self[A]

immut/internal/sparse_array/sparse_array.mbt

@@ -70,7 +70,7 @@ pub fn[X] add(self : SparseArray[X], idx : Int, value : X) -> SparseArray[X] {
 /// `union(self: SparseArray[X], other: SparseArray[X]) -> SparseArray[X]`
 /// 
 /// Combine two sparse arrays into one.
-pub fn[X] union(
+pub fn[X] SparseArray::union(
   self : SparseArray[X],
   other : SparseArray[X],
   union : (X, X) -> X
@@ -106,7 +106,7 @@ pub fn[X] union(
 /// `intersection(self: SparseArray[X], other: SparseArray[X], f: (X, X) -> X) -> SparseArray[X]`
 ///
 /// Only keep indices present in both sparse arrays, and merge values with f.
-pub fn[X] intersection(
+pub fn[X] SparseArray::intersection(
   self : SparseArray[X],
   other : SparseArray[X],
   f : (X, X) -> X
@@ -132,7 +132,7 @@ pub fn[X] intersection(
 /// `difference(self: SparseArray[X], other: SparseArray[X]) -> SparseArray[X]`
 ///
 /// Keep indices and values only present in self but not in other.
-pub fn[X] difference(
+pub fn[X] SparseArray::difference(
   self : SparseArray[X],
   other : SparseArray[X]
 ) -> SparseArray[X] {

immut/internal/sparse_array/sparse_array.mbti

@@ -21,8 +21,6 @@ fn[X] singleton(Int, X) -> SparseArray[X]
 
 fn[X] size(SparseArray[X]) -> Int
 
-fn[X] union(SparseArray[X], SparseArray[X], (X, X) -> X) -> SparseArray[X]
-
 // Types and methods
 pub(all) type Bitset UInt
 fn Bitset::add(Self, Int) -> Self
@@ -41,8 +39,10 @@ pub(all) struct SparseArray[X] {
   data : FixedArray[X]
 }
 fn[X] SparseArray::add(Self[X], Int, X) -> Self[X]
+fn[X] SparseArray::difference(Self[X], Self[X]) -> Self[X]
 fn[X] SparseArray::each(Self[X], (X) -> Unit) -> Unit
 fn[X] SparseArray::has(Self[X], Int) -> Bool
+fn[X] SparseArray::intersection(Self[X], Self[X], (X, X) -> X) -> Self[X]
 fn[X] SparseArray::op_get(Self[X], Int) -> X?
 fn[X] SparseArray::replace(Self[X], Int, X) -> Self[X]
 fn[X] SparseArray::size(Self[X]) -> Int