@fncts/base 0.0.20 → 0.0.21

package/_cjs/collection/immutable/HashSet/api.cjs

@@ -3,31 +3,31 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.beginMutation = exports.add_ = void 0;
-exports.difference_ = difference_;
-exports.every_ = exports.endMutation = void 0;
-exports.exists_ = exists_;
-exports.filterMap_ = filterMap_;
-exports.filter_ = filter_;
+exports.beginMutation = exports.add = void 0;
+exports.difference = difference;
+exports.every = exports.endMutation = void 0;
+exports.exists = exists;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.flatMap = flatMap;
 exports.flatMapDefault = flatMapDefault;
-exports.flatMap_ = flatMap_;
-exports.forEach_ = exports.foldLeft_ = void 0;
+exports.forEach = exports.foldLeft = void 0;
 exports.fromDefault = fromDefault;
 exports.getEq = getEq;
-exports.has_ = void 0;
-exports.intersection_ = intersection_;
-exports.isSubset_ = isSubset_;
-exports.join_ = join_;
+exports.has = void 0;
+exports.intersection = intersection;
+exports.isSubset = isSubset;
+exports.join = join;
 exports.makeDefault = exports.make = void 0;
+exports.map = map;
 exports.mapDefault = mapDefault;
-exports.map_ = map_;
-exports.mutate_ = void 0;
-exports.partitionMap_ = partitionMap_;
-exports.partition_ = partition_;
-exports.size = exports.remove_ = void 0;
-exports.toArray_ = toArray_;
-exports.toggle_ = toggle_;
-exports.union_ = union_;
+exports.mutate = void 0;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.size = exports.remove = void 0;
+exports.toArray = toArray;
+exports.toggle = toggle;
+exports.union = union;
 
 var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/HashEq"));
 
@@ -53,36 +53,38 @@ function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "functio
 
 function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
 
-const add_ = add_1;
-exports.add_ = add_;
+const add = add_1;
+exports.add = add;
 const beginMutation = beginMutation_1;
 exports.beginMutation = beginMutation;
 const endMutation = endMutation_1;
 exports.endMutation = endMutation;
-const forEach_ = forEach_1;
-exports.forEach_ = forEach_;
-const has_ = has_1;
-exports.has_ = has_;
+const forEach = forEach_1;
+exports.forEach = forEach;
+const has = has_1;
+exports.has = has;
 const make = make_1;
 exports.make = make;
 const makeDefault = makeDefault_1;
 exports.makeDefault = makeDefault;
-const mutate_ = mutate_1;
-exports.mutate_ = mutate_;
-const remove_ = remove_1;
-exports.remove_ = remove_;
+const mutate = mutate_1;
+exports.mutate = mutate;
+const remove = remove_1;
+exports.remove = remove;
 const size = size_1;
 exports.size = size;
-const foldLeft_ = foldLeft_1;
-exports.foldLeft_ = foldLeft_;
-const every_ = every_1;
-exports.every_ = every_;
+const foldLeft = foldLeft_1;
+exports.foldLeft = foldLeft;
+const every = every_1;
+exports.every = every;
 
 /**
- * @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 set => {
+    return modifyHash(set, value, set.config.hash(value), false);
+  };
 }
 /**
  * Mark `set` as mutable.
@@ -108,20 +110,24 @@ function endMutation_1(set) {
 /**
  * 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 map => {
+    foldLeft_1(undefined, (_, value) => f(value, map))(map);
+  };
 }
 /**
- * @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 set => {
+    return hasHash(set, value, set.config.hash(value));
+  };
 }
 /**
  * @tsplus static fncts.HashSetOps make
@@ -145,31 +151,35 @@ function makeDefault_1() {
 
 
 function fromDefault(...values) {
-  return mutate_1(makeDefault_1(), set => {
+  return mutate_1(set => {
     values.forEach(v => {
-      add_1(set, v);
+      add_1(v)(set);
     });
-  });
+  })(makeDefault_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 set => {
+    return modifyHash(set, value, set.config.hash(value), true);
+  };
 }
 /**
  * Calculate the number of keys pairs in a set
@@ -184,66 +194,72 @@ function size_1(set) {
 /**
  * If element is present remove it, if not add it
  *
- * @tsplus fluent fncts.HashSet toggle
+ * @tsplus pipeable fncts.HashSet toggle
  */
 
 
-function toggle_(set, a) {
-  return (has_1(set, a) ? remove_1 : add_1)(set, a);
+function toggle(a) {
+  return set => {
+    return has_1(a)(set) ? remove_1(a)(set) : add_1(a)(set);
+  };
 }
 /**
  * Projects a Set through a function
  */
 
 
-function map_(C) {
+function map(C) {
   const r = make_1(C);
-  return (fa, f) => mutate_1(r, r => {
-    forEach_1(fa, e => {
+  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
  */
 
 
-function mapDefault(self, f) {
-  return map_(tsplus_module_1.StructuralStrict)(self, f);
+function mapDefault(f) {
+  return self => {
+    return map(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Map + Flatten
  */
 
 
-function flatMap_(C) {
+function flatMap(C) {
   const r = make_1(C);
-  return (set, f) => mutate_1(r, r => {
-    forEach_1(set, e => {
+  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
  */
 
 
-function flatMapDefault(self, f) {
-  return flatMap_(tsplus_module_1.StructuralStrict)(self, f);
+function flatMapDefault(f) {
+  return self => {
+    return flatMap(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Creates an equal for a set
@@ -266,7 +282,7 @@ function getEq() {
       let eq = true;
 
       for (const vx of x) {
-        if (!has_1(y, vx)) {
+        if (!has_1(vx)(y)) {
           eq = false;
           break;
         }
@@ -277,224 +293,246 @@ function getEq() {
   });
 }
 
-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);
-      }
-    });
-  });
+function filter(predicate) {
+  return set => {
+    const r = make_1(set.config);
+    return mutate_1(r => {
+      forEach_1(v => {
+        if (predicate(v)) {
+          add_1(v)(r);
+        }
+      })(set);
+    })(r);
+  };
 }
 
-function filterMap_(B) {
-  return (fa, f) => {
+function filterMap(B) {
+  return f => fa => {
     const out = beginMutation_1(make_1(B));
-    forEach_1(fa, a => {
+    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);
   };
 }
 
-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 (0, _function.tuple)(endMutation_1(left), endMutation_1(right));
+function partition(p) {
+  return self => {
+    const right = beginMutation_1(make_1(self.config));
+    const left = beginMutation_1(make_1(self.config));
+    forEach_1(v => {
+      if (p(v)) {
+        add_1(v)(right);
+      } else {
+        add_1(v)(left);
+      }
+    })(self);
+    return (0, _function.tuple)(endMutation_1(left), endMutation_1(right));
+  };
 }
 /**
  * Partition set values using predicate
  */
 
 
-function partitionMap_(B, C) {
-  return (fa, f) => {
+function partitionMap(B, C) {
+  return f => fa => {
     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);
+    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)];
   };
 }
 /**
  * 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);
+function foldLeft_1(b, f) {
+  return fa => {
+    const root = fa._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();
+    while (toVisit.hasNext) {
+      const children = toVisit.pop();
 
-    for (let i = 0, len = children.length; i < len;) {
-      const child = children[i++];
+      for (let i = 0, len = children.length; i < len;) {
+        const child = children[i++];
 
-      if (child && !(0, _definition3.isEmptyNode)(child)) {
-        if (child._tag === "LeafNode") {
-          // eslint-disable-next-line no-param-reassign
-          b = f(b, child.value);
-        } else {
-          toVisit.push(child.children);
+        if (child && !(0, _definition3.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
  */
 
 
-function join_(self, separator) {
-  if (self.size === 0) {
-    return "";
-  }
+function join(separator) {
+  return self => {
+    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;
+    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;
+    return s;
+  };
 }
 /**
  * Form the set difference
  *
- * @tsplus fluent fncts.HashSet difference
+ * @tsplus pipeable fncts.HashSet difference
  */
 
 
-function difference_(x, y) {
-  return mutate_1(x, s => {
-    for (const k of y) {
-      remove_1(s, k);
-    }
-  });
+function difference(y) {
+  return x => {
+    return mutate_1(s => {
+      for (const k of y) {
+        remove_1(k)(s);
+      }
+    })(x);
+  };
 }
 /**
  * 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
  */
 
 
-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);
+function intersection(that) {
+  return self => {
+    const out = make_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
  */
 
 
-function isSubset_(x, y) {
-  return every_1(x, a => has_1(y, a));
+function isSubset(y) {
+  return x => every_1(a => has_1(a)(y))(x);
 }
 /**
  * true if one or more elements match predicate
  *
- * @tsplus fluent fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet exists
  */
 
 
-function exists_(set, predicate) {
-  let found = false;
+function exists(predicate) {
+  return set => {
+    let found = false;
 
-  for (const e of set) {
-    found = predicate(e);
+    for (const e of set) {
+      found = predicate(e);
 
-    if (found) {
-      break;
+      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
  */
 
 
-function union_(l, r) {
-  return mutate_1(l, x => {
-    for (const a of r) {
-      add_1(x, a);
-    }
-  });
+function union(r) {
+  return l => {
+    return mutate_1(x => {
+      for (const a of r) {
+        add_1(a)(x);
+      }
+    })(l);
+  };
 }
 /**
  * @tsplus static fncts.HashSet toArray
  */
 
 
-function toArray_(set, O) {
+function toArray(set, O) {
   const r = [];
-  forEach_1(set, a => r.push(a));
+  forEach_1(a => r.push(a))(set);
   return r.sort(O.compare);
 }
 /*