@fncts/base 0.0.20 → 0.0.22

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

@@ -3,579 +3,524 @@
 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.flatMapDefault = flatMapDefault;
-exports.flatMap_ = flatMap_;
-exports.forEach_ = exports.foldLeft_ = void 0;
-exports.fromDefault = fromDefault;
+exports.beginMutation = exports.add = void 0;
+exports.difference = difference;
+exports.every = exports.endMutation = exports.emptyWith = exports.empty = void 0;
+exports.filter = filter;
+exports.filterMap = filterMap;
+exports.filterMapWith = filterMapWith;
+exports.flatMap = flatMap;
+exports.flatMapWith = flatMapWith;
+exports.forEach = exports.foldLeft = void 0;
 exports.getEq = getEq;
-exports.has_ = void 0;
-exports.intersection_ = intersection_;
-exports.isSubset_ = isSubset_;
-exports.join_ = join_;
-exports.makeDefault = exports.make = void 0;
-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_;
-
-var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/HashEq"));
-
-var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/Eq/definition"));
-
+exports.has = void 0;
+exports.intersection = intersection;
+exports.isSubset = isSubset;
+exports.join = join;
+exports.make = make;
+exports.map = map;
+exports.mapWith = mapWith;
+exports.mutate = void 0;
+exports.partition = partition;
+exports.partitionMap = partitionMap;
+exports.partitionMapWith = partitionMapWith;
+exports.size = exports.remove = void 0;
+exports.some = some;
+exports.toArray = toArray;
+exports.toggle = toggle;
+exports.union = union;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/HashEq"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Eq/definition"));
 var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
-
 var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
-
 var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/internal/Stack"));
-
 var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
-
 var _internal = /*#__PURE__*/require("@fncts/base/collection/immutable/HashMap/internal");
-
 var _definition3 = /*#__PURE__*/require("@fncts/base/collection/immutable/HashSet/definition");
-
 var _function = /*#__PURE__*/require("@fncts/base/data/function");
-
 var P = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass"));
-
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
-
 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 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 forEach = forEach_1;
+exports.forEach = forEach;
+const has = has_1;
+exports.has = has;
+const emptyWith = emptyWith_1;
+exports.emptyWith = emptyWith;
+const empty = empty_1;
+exports.empty = empty;
+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 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 _definition3.HashSet(true, set._edit + 1, set.config, set._root, set._size);
+function beginMutation_1(self) {
+  return new _definition3.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 _definition3.HashSet(false, 0, config, _definition3._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
  */
-
-
-function fromDefault(...values) {
-  return mutate_1(makeDefault_1(), set => {
+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
  */
-
-
-function toggle_(set, a) {
-  return (has_1(set, a) ? remove_1 : add_1)(set, a);
+function toggle(a) {
+  return self => {
+    return has_1(a)(self) ? remove_1(a)(self) : add_1(a)(self);
+  };
 }
 /**
  * Projects a Set through a function
  */
-
-
-function map_(C) {
-  const r = make_1(C);
-  return (fa, f) => mutate_1(r, r => {
-    forEach_1(fa, e => {
+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
  */
-
-
-function mapDefault(self, f) {
-  return map_(tsplus_module_1.StructuralStrict)(self, f);
+function map(f) {
+  return self => {
+    return mapWith(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Map + Flatten
  */
-
-
-function flatMap_(C) {
-  const r = make_1(C);
-  return (set, f) => mutate_1(r, r => {
-    forEach_1(set, e => {
+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
  */
-
-
-function flatMapDefault(self, f) {
-  return flatMap_(tsplus_module_1.StructuralStrict)(self, f);
+function flatMap(f) {
+  return self => {
+    return flatMapWith(tsplus_module_1.StructuralStrict)(f)(self);
+  };
 }
 /**
  * Creates an equal for a set
  *
  * @tsplus static fncts.HashSetOps getEq
  */
-
-
 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;
     }
   });
 }
-
-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 = emptyWith_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) => {
-    const out = beginMutation_1(make_1(B));
-    forEach_1(fa, a => {
+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);
   };
 }
-
-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));
+/**
+ * @tsplus pipeable fncts.HashSet filterMap
+ */
+function filterMap(f) {
+  return filterMapWith(tsplus_module_1.StructuralStrict)(f);
+}
+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 (0, _function.tuple)(endMutation_1(left), endMutation_1(right));
+  };
 }
 /**
  * Partition set values using predicate
  */
-
-
-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);
+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
+ */
+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 && !(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);
+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 && !(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 "";
-  }
-
-  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;
+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
  */
-
-
-function difference_(x, y) {
-  return mutate_1(x, s => {
-    for (const k of y) {
-      remove_1(s, k);
-    }
-  });
+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
  */
-
-
-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 = 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
  */
-
-
-function isSubset_(x, y) {
-  return every_1(x, a => has_1(y, a));
+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
  */
-
-
-function exists_(set, predicate) {
-  let found = false;
-
-  for (const e of set) {
-    found = predicate(e);
-
-    if (found) {
-      break;
+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
  */
-
-
-function union_(l, r) {
-  return mutate_1(l, x => {
-    for (const a of r) {
-      add_1(x, a);
-    }
-  });
+function union(that) {
+  return self => {
+    return mutate_1(x => {
+      for (const a of that) {
+        add_1(a)(x);
+      }
+    })(self);
+  };
 }
 /**
- * @tsplus static fncts.HashSet toArray
- */
-
-
-function toArray_(set, O) {
-  const r = [];
-  forEach_1(set, a => r.push(a));
-  return r.sort(O.compare);
-}
-/*
- * -------------------------------------------------------------------------------------------------
- * internal
- * -------------------------------------------------------------------------------------------------
+ * @tsplus pipeable fncts.HashSet toArray
  */
-
-
+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 _definition3.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 = (0, _internal.hashFragment)(shift, hash);
           const bit = (0, _internal.toBitmap)(frag);
-
           if (node.mask & bit) {
             node = node.children[(0, _internal.fromBitmap)(node.mask, bit)];
             shift += _internal.SIZE;
             break;
           }
-
           return tsplus_module_6.nothing();
         }
-
       case "ArrayNode":
         {
           node = node.children[(0, _internal.hashFragment)(shift, hash)];
-
           if (node) {
             shift += _internal.SIZE;
             break;
           }
-
           return tsplus_module_6.nothing();
         }
-
       default:
         {
           return tsplus_module_6.nothing();
@@ -583,7 +528,6 @@ function tryGetHash(set, value, hash) {
     }
   }
 }
-
 function hasHash(set, value, hash) {
   return tsplus_module_3.isJust(tryGetHash(set, value, hash));
 }