@fncts/base 0.0.20 → 0.0.22

package/_mjs/collection/immutable/HashSet/api.mjs

@@ -1,507 +1,482 @@
-import * as tsplus_module_1 from "@fncts/base/typeclass/HashEq";
-import * as tsplus_module_2 from "@fncts/base/typeclass/Eq/definition";
+import * as tsplus_module_1 from "@fncts/base/data/HashEq";
+import * as tsplus_module_2 from "@fncts/base/data/Eq/definition";
 import * as tsplus_module_3 from "@fncts/base/data/Maybe/definition";
 import * as tsplus_module_4 from "@fncts/base/data/Either/destructors";
 import * as tsplus_module_5 from "@fncts/base/internal/Stack";
 import * as tsplus_module_6 from "@fncts/base/data/Maybe/constructors";
-export const add_ = add_1;
+export const add = add_1;
 export const beginMutation = beginMutation_1;
 export const endMutation = endMutation_1;
-export const forEach_ = forEach_1;
-export const has_ = has_1;
-export const make = make_1;
-export const makeDefault = makeDefault_1;
-export const mutate_ = mutate_1;
-export const remove_ = remove_1;
+export const forEach = forEach_1;
+export const has = has_1;
+export const emptyWith = emptyWith_1;
+export const empty = empty_1;
+export const mutate = mutate_1;
+export const remove = remove_1;
 export const size = size_1;
-export const foldLeft_ = foldLeft_1;
-export const every_ = every_1;
+export const foldLeft = foldLeft_1;
+export const every = every_1;
 import { fromBitmap, hashFragment, SIZE, toBitmap } from "@fncts/base/collection/immutable/HashMap/internal";
 import { _EmptyNode, HashSet, isEmptyNode } from "@fncts/base/collection/immutable/HashSet/definition";
 import { tuple } from "@fncts/base/data/function";
 import { Stack } from "@fncts/base/internal/Stack";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.HashSet add
+ * @tsplus pipeable fncts.HashSet add
  */
-
-function add_1(set, value) {
-  return modifyHash(set, value, set.config.hash(value), false);
+function add_1(value) {
+  return self => {
+    return modifyHash(self, value, self.config.hash(value), false);
+  };
 }
 /**
  * Mark `set` as mutable.
  *
  * @tsplus getter fncts.HashSet beginMutation
  */
-
-
-function beginMutation_1(set) {
-  return new HashSet(true, set._edit + 1, set.config, set._root, set._size);
+function beginMutation_1(self) {
+  return new HashSet(true, self._edit + 1, self.config, self._root, self._size);
 }
 /**
  * Mark `set` as immutable.
  *
  * @tsplus getter fncts.HashSet endMutation
  */
-
-
-function endMutation_1(set) {
-  set._editable = false;
-  return set;
+function endMutation_1(self) {
+  self._editable = false;
+  return self;
 }
 /**
  * Appy f to each element
  *
- * @tsplus fluent fncts.HashSet forEach
+ * @tsplus pipeable fncts.HashSet forEach
  */
-
-
-function forEach_1(map, f) {
-  foldLeft_1(map, undefined, (_, value) => f(value, map));
+function forEach_1(f) {
+  return self => {
+    foldLeft_1(undefined, (_, value) => f(value, self))(self);
+  };
 }
 /**
- * @tsplus fluent fncts.HashSet has
+ * @tsplus pipeable fncts.HashSet has
  */
-
-
-function has_1(set, value) {
-  return hasHash(set, value, set.config.hash(value));
+function has_1(value) {
+  return self => {
+    return hasHash(self, value, self.config.hash(value));
+  };
 }
 /**
- * @tsplus static fncts.HashSetOps make
+ * @tsplus static fncts.HashSetOps emptyWith
  */
-
-
-function make_1(config) {
+function emptyWith_1(config) {
   return new HashSet(false, 0, config, _EmptyNode, 0);
 }
 /**
- * @tsplus static fncts.HashSetOps makeDefault
+ * @tsplus static fncts.HashSetOps empty
  */
-
-
-function makeDefault_1() {
-  return make_1(tsplus_module_1.StructuralStrict);
+function empty_1() {
+  return emptyWith_1(tsplus_module_1.StructuralStrict);
 }
 /**
- * @tsplus static fncts.HashSetOps fromDefault
+ * @tsplus static fncts.HashSetOps make
  */
-
-
-export function fromDefault(...values) {
-  return mutate_1(makeDefault_1(), set => {
+export function make(...values) {
+  return mutate_1(set => {
     values.forEach(v => {
-      add_1(set, v);
+      add_1(v)(set);
     });
-  });
+  })(empty_1());
 }
 /**
  * Mutate `set` within the context of `f`.
  *
- * @tsplus fluent fncts.HashSet mutate
+ * @tsplus pipeable fncts.HashSet mutate
  */
-
-function mutate_1(set, transient) {
-  const s = beginMutation_1(set);
-  transient(s);
-  return endMutation_1(s);
+function mutate_1(transient) {
+  return self => {
+    const s = beginMutation_1(self);
+    transient(s);
+    return endMutation_1(s);
+  };
 }
 /**
- * @tsplus fluent fncts.HashSet remove
+ * @tsplus pipeable fncts.HashSet remove
  */
-
-
-function remove_1(set, value) {
-  return modifyHash(set, value, set.config.hash(value), true);
+function remove_1(value) {
+  return self => {
+    return modifyHash(self, value, self.config.hash(value), true);
+  };
 }
 /**
  * Calculate the number of keys pairs in a set
  *
  * @tsplus getter fncts.HashSet size
  */
-
-
-function size_1(set) {
-  return set._size;
+function size_1(self) {
+  return self._size;
 }
 /**
  * If element is present remove it, if not add it
  *
- * @tsplus fluent fncts.HashSet toggle
+ * @tsplus pipeable fncts.HashSet toggle
  */
-
-
-export function toggle_(set, a) {
-  return (has_1(set, a) ? remove_1 : add_1)(set, a);
+export function toggle(a) {
+  return self => {
+    return has_1(a)(self) ? remove_1(a)(self) : add_1(a)(self);
+  };
 }
 /**
  * Projects a Set through a function
  */
-
-export function map_(C) {
-  const r = make_1(C);
-  return (fa, f) => mutate_1(r, r => {
-    forEach_1(fa, e => {
+export function mapWith(B) {
+  const r = emptyWith_1(B);
+  return f => fa => mutate_1(r => {
+    forEach_1(e => {
       const v = f(e);
-
-      if (!has_1(r, v)) {
-        add_1(r, v);
+      if (!has_1(v)(r)) {
+        add_1(v)(r);
       }
-    });
+    })(fa);
     return r;
-  });
+  })(r);
 }
 /**
  * Projects a Set through a function
  *
- * @tsplus fluent fncts.HashSet map
+ * @tsplus pipeable fncts.HashSet map
  */
-
-export function mapDefault(self, f) {
-  return map_(tsplus_module_1.StructuralStrict)(self, f);
+export function map(f) {
+  return self => {
+    return mapWith(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Map + Flatten
  */
-
-export function flatMap_(C) {
-  const r = make_1(C);
-  return (set, f) => mutate_1(r, r => {
-    forEach_1(set, e => {
+export function flatMapWith(C) {
+  const r = emptyWith_1(C);
+  return f => self => mutate_1(r => {
+    forEach_1(e => {
       for (const a of f(e)) {
-        if (!has_1(r, a)) {
-          add_1(r, a);
+        if (!has_1(a)(r)) {
+          add_1(a)(r);
         }
       }
-    });
+    })(self);
     return r;
-  });
+  })(r);
 }
 /**
- * @tsplus fluent fncts.HashSet flatMap
+ * @tsplus pipeable fncts.HashSet flatMap
  */
-
-export function flatMapDefault(self, f) {
-  return flatMap_(tsplus_module_1.StructuralStrict)(self, f);
+export function flatMap(f) {
+  return self => {
+    return flatMapWith(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Creates an equal for a set
  *
  * @tsplus static fncts.HashSetOps getEq
  */
-
 export function getEq() {
-  return tsplus_module_2.mkEq({
-    equals: (x, y) => {
+  return tsplus_module_2.makeEq({
+    equals: y => x => {
       if (y === x) {
         return true;
       }
-
       if (size_1(x) !== size_1(y)) {
         return false;
       }
-
       let eq = true;
-
       for (const vx of x) {
-        if (!has_1(y, vx)) {
+        if (!has_1(vx)(y)) {
           eq = false;
           break;
         }
       }
-
       return eq;
     }
   });
 }
-export function filter_(set, predicate) {
-  const r = make_1(set.config);
-  return mutate_1(r, r => {
-    forEach_1(set, v => {
-      if (predicate(v)) {
-        add_1(r, v);
-      }
-    });
-  });
+export function filter(predicate) {
+  return set => {
+    const r = emptyWith_1(set.config);
+    return mutate_1(r => {
+      forEach_1(v => {
+        if (predicate(v)) {
+          add_1(v)(r);
+        }
+      })(set);
+    })(r);
+  };
 }
-export function filterMap_(B) {
-  return (fa, f) => {
-    const out = beginMutation_1(make_1(B));
-    forEach_1(fa, a => {
+export function filterMapWith(B) {
+  return f => fa => {
+    const out = beginMutation_1(emptyWith_1(B));
+    forEach_1(a => {
       const ob = f(a);
-
       if (tsplus_module_3.isJust(ob)) {
-        add_1(out, ob.value);
+        add_1(ob.value)(out);
       }
-    });
+    })(fa);
     return endMutation_1(out);
   };
 }
-export function partition_(self, p) {
-  const right = beginMutation_1(make_1(self.config));
-  const left = beginMutation_1(make_1(self.config));
-  forEach_1(self, v => {
-    if (p(v)) {
-      add_1(right, v);
-    } else {
-      add_1(left, v);
-    }
-  });
-  return tuple(endMutation_1(left), endMutation_1(right));
+/**
+ * @tsplus pipeable fncts.HashSet filterMap
+ */
+export function filterMap(f) {
+  return filterMapWith(tsplus_module_1.StructuralStrict)(f);
+}
+export function partition(p) {
+  return self => {
+    const right = beginMutation_1(emptyWith_1(self.config));
+    const left = beginMutation_1(emptyWith_1(self.config));
+    forEach_1(v => {
+      if (p(v)) {
+        add_1(v)(right);
+      } else {
+        add_1(v)(left);
+      }
+    })(self);
+    return tuple(endMutation_1(left), endMutation_1(right));
+  };
 }
 /**
  * Partition set values using predicate
  */
-
-export function partitionMap_(B, C) {
-  return (fa, f) => {
-    const right = beginMutation_1(make_1(C));
-    const left = beginMutation_1(make_1(B));
-    forEach_1(fa, v => {
-      tsplus_module_4.match_(f(v), b => {
-        add_1(left, b);
+export function partitionMapWith(B, C) {
+  return f => fa => {
+    const right = beginMutation_1(emptyWith_1(C));
+    const left = beginMutation_1(emptyWith_1(B));
+    forEach_1(v => {
+      tsplus_module_4.match(b => {
+        add_1(b)(left);
       }, c => {
-        add_1(right, c);
-      });
-    });
+        add_1(c)(right);
+      })(f(v));
+    })(fa);
     return [endMutation_1(left), endMutation_1(right)];
   };
 }
+/**
+ * @tsplus pipeable fncts.HashSet partitionMap
+ */
+export function partitionMap(f) {
+  return partitionMapWith(tsplus_module_1.StructuralStrict, tsplus_module_1.StructuralStrict)(f);
+}
 /**
  * Reduce a state over the set elements
  *
- * @tsplus fluent fncts.HashSet foldLeft
+ * @tsplus pipeable fncts.HashSet foldLeft
  */
-
-function foldLeft_1(fa, b, f) {
-  const root = fa._root;
-  if (root._tag === "LeafNode") return f(b, root.value);
-  if (root._tag === "EmptyNode") return b;
-  const toVisit = tsplus_module_5.mkStack();
-  toVisit.push(root.children);
-
-  while (toVisit.hasNext) {
-    const children = toVisit.pop();
-
-    for (let i = 0, len = children.length; i < len;) {
-      const child = children[i++];
-
-      if (child && !isEmptyNode(child)) {
-        if (child._tag === "LeafNode") {
-          // eslint-disable-next-line no-param-reassign
-          b = f(b, child.value);
-        } else {
-          toVisit.push(child.children);
+function foldLeft_1(b, f) {
+  return self => {
+    const root = self._root;
+    if (root._tag === "LeafNode") return f(b, root.value);
+    if (root._tag === "EmptyNode") return b;
+    const toVisit = tsplus_module_5.makeStack();
+    toVisit.push(root.children);
+    while (toVisit.hasNext) {
+      const children = toVisit.pop();
+      for (let i = 0, len = children.length; i < len;) {
+        const child = children[i++];
+        if (child && !isEmptyNode(child)) {
+          if (child._tag === "LeafNode") {
+            // eslint-disable-next-line no-param-reassign
+            b = f(b, child.value);
+          } else {
+            toVisit.push(child.children);
+          }
         }
       }
     }
-  }
-
-  return b;
+    return b;
+  };
 }
 /**
- * @tsplus fluent fncts.HashSet join
+ * @tsplus pipeable fncts.HashSet join
  */
-
-
-export function join_(self, separator) {
-  if (self.size === 0) {
-    return "";
-  }
-
-  const iterator = self[Symbol.iterator]();
-  let first = true;
-  let s = "";
-  let result;
-
-  while (!(result = iterator.next()).done) {
-    if (first) {
-      first = false;
-      s += result.value;
-      result = iterator.next();
-    } else {
-      s += separator;
-      s += result.value;
+export function join(separator) {
+  return self => {
+    if (self.size === 0) {
+      return "";
     }
-  }
-
-  return s;
+    const iterator = self[Symbol.iterator]();
+    let first = true;
+    let s = "";
+    let result;
+    while (!(result = iterator.next()).done) {
+      if (first) {
+        first = false;
+        s += result.value;
+        result = iterator.next();
+      } else {
+        s += separator;
+        s += result.value;
+      }
+    }
+    return s;
+  };
 }
 /**
  * Form the set difference
  *
- * @tsplus fluent fncts.HashSet difference
+ * @tsplus pipeable fncts.HashSet difference
  */
-
-export function difference_(x, y) {
-  return mutate_1(x, s => {
-    for (const k of y) {
-      remove_1(s, k);
-    }
-  });
+export function difference(that) {
+  return self => {
+    return mutate_1(s => {
+      for (const k of that) {
+        remove_1(k)(s);
+      }
+    })(self);
+  };
 }
 /**
  * true if all elements match predicate
  *
- * @tsplus fluent fncts.HashSet every
+ * @tsplus pipeable fncts.HashSet every
  */
-
-function every_1(self, predicate) {
-  for (const e of self) {
-    if (!predicate(e)) {
-      return false;
+function every_1(predicate) {
+  return self => {
+    for (const e of self) {
+      if (!predicate(e)) {
+        return false;
+      }
     }
-  }
-
-  return true;
+    return true;
+  };
 }
 /**
  * The set of elements which are in both the first and second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ *
+ * @tsplus pipeable fncts.HashSet intersection
  */
-
-
-export function intersection_(self, that) {
-  const out = make_1(self.config);
-  return mutate_1(out, y => {
-    for (const k of that) {
-      if (has_1(self, k)) {
-        add_1(y, k);
+export function intersection(that) {
+  return self => {
+    const out = emptyWith_1(self.config);
+    return mutate_1(y => {
+      for (const k of that) {
+        if (has_1(k)(self)) {
+          add_1(k)(y);
+        }
       }
-    }
-  });
+    })(out);
+  };
 }
 /**
  * `true` if and only if every element in the first set is an element of the second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ *
+ * @tsplus pipeable fncts.HashSet isSubset
  */
-
-export function isSubset_(x, y) {
-  return every_1(x, a => has_1(y, a));
+export function isSubset(that) {
+  return self => every_1(a => has_1(a)(that))(self);
 }
 /**
  * true if one or more elements match predicate
  *
- * @tsplus fluent fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet some
  */
-
-export function exists_(set, predicate) {
-  let found = false;
-
-  for (const e of set) {
-    found = predicate(e);
-
-    if (found) {
-      break;
+export function some(predicate) {
+  return self => {
+    let found = false;
+    for (const e of self) {
+      found = predicate(e);
+      if (found) {
+        break;
+      }
     }
-  }
-
-  return found;
+    return found;
+  };
 }
 /**
  * Form the union of two sets,
  *
  * the hash and equal of the 2 sets has to be the same
  *
- * @tsplus fluent fncts.HashSet union
+ * @tsplus pipeable fncts.HashSet union
  */
-
-export function union_(l, r) {
-  return mutate_1(l, x => {
-    for (const a of r) {
-      add_1(x, a);
-    }
-  });
+export function union(that) {
+  return self => {
+    return mutate_1(x => {
+      for (const a of that) {
+        add_1(a)(x);
+      }
+    })(self);
+  };
 }
 /**
- * @tsplus static fncts.HashSet toArray
+ * @tsplus pipeable fncts.HashSet toArray
  */
-
-export function toArray_(set, O) {
-  const r = [];
-  forEach_1(set, a => r.push(a));
-  return r.sort(O.compare);
-}
-/*
- * -------------------------------------------------------------------------------------------------
- * internal
- * -------------------------------------------------------------------------------------------------
- */
-
+export function toArray(O) {
+  return self => {
+    const r = [];
+    forEach_1(a => r.push(a))(self);
+    return r.sort((a, b) => O.compare(b)(a));
+  };
+}
 function setTree(set, newRoot, newSize) {
   if (set._editable) {
     set._root = newRoot;
     set._size = newSize;
     return set;
   }
-
   return newRoot === set._root ? set : new HashSet(set._editable, set._edit, set.config, newRoot, newSize);
 }
-
 function modifyHash(set, value, hash, remove) {
   const size = {
     value: set._size
   };
-
   const newRoot = set._root.modify(remove, set._editable ? set._edit : NaN, set.config.equals, 0, hash, value, size);
-
   return setTree(set, newRoot, size.value);
 }
-
 function tryGetHash(set, value, hash) {
   let node = set._root;
   let shift = 0;
-  const eq = set.config.equals; // eslint-disable-next-line no-constant-condition
-
+  const eq = set.config.equals;
+  // eslint-disable-next-line no-constant-condition
   while (true) {
     switch (node._tag) {
       case "LeafNode":
         {
-          return eq(node.value, value) ? tsplus_module_6.just(node.value) : tsplus_module_6.nothing();
+          return eq(value)(node.value) ? tsplus_module_6.just(node.value) : tsplus_module_6.nothing();
         }
-
       case "CollisionNode":
         {
           if (hash === node.hash) {
             const children = node.children;
-
             for (let i = 0, len = children.length; i < len; ++i) {
               const child = children[i];
-              if ("value" in child && eq(child.value, value)) return tsplus_module_6.just(child.value);
+              if ("value" in child && eq(value)(child.value)) return tsplus_module_6.just(child.value);
             }
           }
-
           return tsplus_module_6.nothing();
         }
-
       case "IndexNode":
         {
           const frag = hashFragment(shift, hash);
           const bit = toBitmap(frag);
-
           if (node.mask & bit) {
             node = node.children[fromBitmap(node.mask, bit)];
             shift += SIZE;
             break;
           }
-
           return tsplus_module_6.nothing();
         }
-
       case "ArrayNode":
         {
           node = node.children[hashFragment(shift, hash)];
-
           if (node) {
             shift += SIZE;
             break;
           }
-
           return tsplus_module_6.nothing();
         }
-
       default:
         {
           return tsplus_module_6.nothing();
@@ -509,7 +484,6 @@ function tryGetHash(set, value, hash) {
     }
   }
 }
-
 function hasHash(set, value, hash) {
   return tsplus_module_3.isJust(tryGetHash(set, value, hash));
 }