@fncts/base 0.0.1

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

@@ -0,0 +1,873 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.filterWithIndex_ = exports.filterMap_ = exports.filterMapWithIndex_ = exports.endMutation = exports.compact = exports.beginMutation = void 0;
+exports.filter_ = filter_;
+exports.flatMapWithIndex_ = void 0;
+exports.flatMap_ = flatMap_;
+exports.foldLeftWithIndex_ = void 0;
+exports.foldLeft_ = foldLeft_;
+exports.forEach_ = exports.forEachWithIndex_ = void 0;
+exports.fromFoldable = fromFoldable;
+exports.get_ = exports.getHash_ = void 0;
+exports.hasHash_ = hasHash_;
+exports.has_ = has_;
+exports.isEmpty = isEmpty;
+exports.keySet = keySet;
+exports.keys = keys;
+exports.make = make;
+exports.mapWithIndex_ = exports.makeWith = exports.makeDefault = void 0;
+exports.map_ = map_;
+exports.partitionWithIndex_ = exports.partitionMap_ = exports.partitionMapWithIndex_ = exports.mutate_ = exports.modify_ = exports.modifyHash_ = void 0;
+exports.partition_ = partition_;
+exports.pop_ = pop_;
+exports.removeMany_ = removeMany_;
+exports.set_ = exports.separate = exports.remove_ = void 0;
+exports.toArray = toArray;
+exports.toList = toList;
+exports.toSetDefault = toSetDefault;
+exports.traverse_ = exports.traverseWithIndex_ = exports.traverseWithIndexSelf = exports.traverseWithIndex = exports.traverseSelf = exports.traverse = void 0;
+exports.unionWith_ = unionWith_;
+exports.union_ = union_;
+exports.unsafeGet_ = unsafeGet_;
+exports.update_ = update_;
+exports.values = values;
+exports.wither_ = exports.witherWithIndex_ = exports.witherWithIndexSelf = exports.witherWithIndex = exports.witherSelf = exports.wither = exports.wilt_ = exports.wiltWithIndex_ = exports.wiltWithIndexSelf = exports.wiltWithIndex = exports.wiltSelf = exports.wilt = void 0;
+
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/HashMap/definition"));
+
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/HashEq"));
+
+var tsplus_module_3 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/definition"));
+
+var tsplus_module_4 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/constructors"));
+
+var tsplus_module_5 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/HashSet/api"));
+
+var tsplus_module_6 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/mutable/ListBuffer"));
+
+var tsplus_module_7 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/api"));
+
+var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+
+var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
+
+var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/destructors"));
+
+var _internal = /*#__PURE__*/require("@fncts/base/collection/immutable/HashMap/internal");
+
+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 makeWith = makeWith_1;
+exports.makeWith = makeWith;
+const makeDefault = makeDefault_1;
+exports.makeDefault = makeDefault;
+const getHash_ = getHash_1;
+exports.getHash_ = getHash_;
+const get_ = get_1;
+exports.get_ = get_;
+const modifyHash_ = modifyHash_1;
+exports.modifyHash_ = modifyHash_;
+const modify_ = modify_1;
+exports.modify_ = modify_;
+const set_ = set_1;
+exports.set_ = set_;
+const remove_ = remove_1;
+exports.remove_ = remove_;
+const beginMutation = beginMutation_1;
+exports.beginMutation = beginMutation;
+const endMutation = endMutation_1;
+exports.endMutation = endMutation;
+const mutate_ = mutate_1;
+exports.mutate_ = mutate_;
+const forEachWithIndex_ = forEachWithIndex_1;
+exports.forEachWithIndex_ = forEachWithIndex_;
+const forEach_ = forEach_1;
+exports.forEach_ = forEach_;
+const mapWithIndex_ = mapWithIndex_1;
+exports.mapWithIndex_ = mapWithIndex_;
+const flatMapWithIndex_ = flatMapWithIndex_1;
+exports.flatMapWithIndex_ = flatMapWithIndex_;
+const compact = compact_1;
+exports.compact = compact;
+const separate = separate_1;
+exports.separate = separate;
+const filterMapWithIndex_ = filterMapWithIndex_1;
+exports.filterMapWithIndex_ = filterMapWithIndex_;
+const filterMap_ = filterMap_1;
+exports.filterMap_ = filterMap_;
+const filterWithIndex_ = filterWithIndex_1;
+exports.filterWithIndex_ = filterWithIndex_;
+const partitionMapWithIndex_ = partitionMapWithIndex_1;
+exports.partitionMapWithIndex_ = partitionMapWithIndex_;
+const partitionMap_ = partitionMap_1;
+exports.partitionMap_ = partitionMap_;
+const partitionWithIndex_ = partitionWithIndex_1;
+exports.partitionWithIndex_ = partitionWithIndex_;
+const foldLeftWithIndex_ = foldLeftWithIndex_1;
+exports.foldLeftWithIndex_ = foldLeftWithIndex_;
+
+/**
+ * Does `map` contain any elements?
+ *
+ * @tsplus getter fncts.HashMap isEmpty
+ */
+function isEmpty(map) {
+  return map && (0, _internal.isEmptyNode)(map.root);
+}
+/**
+ * Creates a new map
+ *
+ * @tsplus static fncts.HashMapOps makeWith
+ */
+
+
+function makeWith_1(config) {
+  return new tsplus_module_1.HashMap(false, 0, config, _internal._EmptyNode, 0);
+}
+/**
+ * @tsplus static fncts.HashMapOps __call
+ */
+
+
+function make(...items) {
+  return mutate_1(makeDefault_1(), map => {
+    for (const [key, value] of items) {
+      set_1(map, key, value);
+    }
+  });
+}
+/**
+ * Make a new map that has randomly cached hash and structural equality
+ *
+ * @tsplus static fncts.HashMapOps makeDefault
+ */
+
+
+function makeDefault_1() {
+  return makeWith_1(tsplus_module_2.StructuralStrict);
+}
+/**
+ * Makes a new map from a Foldable of key-value pairs
+ *
+ * @tsplus fluent fncts.HashMapOps fromFoldable
+ */
+
+
+function fromFoldable(config, S, F) {
+  return fka => {
+    return F.foldLeft_(fka, makeWith_1(config), (b, [k, a]) => {
+      const oa = get_1(b, k);
+
+      if (tsplus_module_3.isJust(oa)) {
+        return set_1(b, k, S.combine_(oa.value, a));
+      } else {
+        return set_1(b, k, a);
+      }
+    });
+  };
+}
+/**
+ * Lookup the value for `key` in `map` using custom hash.
+ *
+ * @tsplus fluent fncts.HashMap getHash
+ */
+
+
+function getHash_1(map, key, hash) {
+  return tryGetHash(map, key, hash);
+}
+/**
+ * Lookup the value for `key` in `map` using internal hash function.
+ *
+ * @tsplus fluent fncts.HashMap get
+ */
+
+
+function get_1(map, key) {
+  return tryGetHash(map, key, map.config.hash(key));
+}
+/**
+ * Does an entry exist for `key` in `map`? Uses custom `hash`.
+ *
+ * @tsplus fluent fncts.HashMap hashHash
+ */
+
+
+function hasHash_(map, key, hash) {
+  return tsplus_module_3.isJust(tryGetHash(map, key, hash));
+}
+/**
+ * Does an entry exist for `key` in `map`? Uses internal hash function.
+ *
+ * @tsplus fluent fncts.HashMap has
+ */
+
+
+function has_(map, key) {
+  return tsplus_module_3.isJust(tryGetHash(map, key, map.config.hash(key)));
+}
+/**
+ * Alter the value stored for `key` in `map` using function `f` using custom hash.
+ *
+ * `f` is invoked with the current value for `k` if it exists,
+ * or no arguments if no such value exists.
+ *
+ * `modify` will always either update or insert a value into the map.
+ * Returns a map with the modified value. Does not alter `map`.
+ *
+ * @tsplus fluent fncts.HashMap modifyHash
+ */
+
+
+function modifyHash_1(map, key, hash, f) {
+  const size = {
+    value: map.size
+  };
+  const newRoot = map.root.modify(map.editable ? map.edit : NaN, map.config.equals_, 0, f, hash, key, size);
+  return setTree(map, newRoot, size.value);
+}
+/**
+ * Alter the value stored for `key` in `map` using function `f` using internal hash function.
+ *
+ * `f` is invoked with the current value for `k` if it exists,
+ * or no arguments if no such value exists.
+ *
+ * `modify` will always either update or insert a value into the map.
+ * Returns a map with the modified value. Does not alter `map`.
+ *
+ * @tsplus fluent fncts.HashMap modify
+ */
+
+
+function modify_1(map, key, f) {
+  return modifyHash_1(map, key, map.config.hash(key), f);
+}
+/**
+ * Store `value` for `key` in `map` using internal hash function.
+ *
+ * @tsplus fluent fncts.HashMap set
+ */
+
+
+function set_1(map, key, value) {
+  return modify_1(map, key, () => tsplus_module_4.just(value));
+}
+/**
+ * Remove the entry for `key` in `map` using internal hash.
+ *
+ * @tsplus fluent fncts.HashMap remove
+ */
+
+
+function remove_1(map, key) {
+  return modify_1(map, key, () => tsplus_module_4.nothing());
+}
+/**
+ * Remove many keys
+ *
+ * @tsplus fluent fncts.HashMap removeMany
+ */
+
+
+function removeMany_(map, keys) {
+  return mutate_1(map, m => {
+    for (const k of keys) {
+      remove_1(m, k);
+    }
+  });
+}
+/**
+ * Mark `map` as mutable.
+ *
+ * @tsplus getter fncts.HashMap beginMutation
+ */
+
+
+function beginMutation_1(map) {
+  return new tsplus_module_1.HashMap(true, map.edit + 1, map.config, map.root, map.size);
+}
+/**
+ * Mark `map` as immutable.
+ *
+ * @tsplus getter fncts.HashMap endMutation
+ */
+
+
+function endMutation_1(map) {
+  map.editable = false;
+  return map;
+}
+/**
+ * Mutate `map` within the context of `f`.
+ *
+ * @tsplus fluent fncts.HashMap mutate
+ */
+
+
+function mutate_1(map, f) {
+  const transient = beginMutation_1(map);
+  f(transient);
+  return endMutation_1(transient);
+}
+/**
+ * Get an IterableIterator of the map keys
+ *
+ * @tsplus getter fncts.HashMap keys
+ */
+
+
+function keys(map) {
+  return new tsplus_module_1.HashMapIterator(map, ([k]) => k);
+}
+/**
+ * Get the set of keys
+ *
+ * @tsplus getter fncts.HashMap keySet
+ */
+
+
+function keySet(self) {
+  return tsplus_module_5.mutate_(tsplus_module_5.make(self.config), set => {
+    forEachWithIndex_1(self, k => {
+      tsplus_module_5.add_(set, k);
+    });
+  });
+}
+/**
+ * Get the set of values
+ *
+ * @tsplus getter fncts.HashMap keySetDefault
+ */
+
+
+function toSetDefault(map) {
+  return tsplus_module_5.mutate_(tsplus_module_5.makeDefault(), set => {
+    forEach_1(map, v => {
+      tsplus_module_5.add_(set, v);
+    });
+  });
+}
+/**
+ * Get the set of values
+ *
+ * @tsplus getter fncts.HashMap toList
+ */
+
+
+function toList(map) {
+  const buffer = new tsplus_module_6.ListBuffer();
+  forEachWithIndex_1(map, (k, v) => {
+    buffer.append([k, v]);
+  });
+  return buffer.toList;
+}
+/**
+ * Get the set of values
+ *
+ * @tsplus getter fncts.HashMap toArray
+ */
+
+
+function toArray(map) {
+  const buffer = Array(map.size);
+  let i = 0;
+  forEachWithIndex_1(map, (k, v) => {
+    buffer[i] = [k, v];
+    i++;
+  });
+  return buffer;
+}
+/**
+ * Get an IterableIterator of the map values
+ *
+ * @tsplus getter fncts.HashMap values
+ */
+
+
+function values(map) {
+  return new tsplus_module_1.HashMapIterator(map, ([, v]) => v);
+}
+/**
+ * Update a value if exists
+ *
+ * @tsplus fluent fncts.HashMap update
+ */
+
+
+function update_(map, key, f) {
+  return modify_1(map, key, v => tsplus_module_7.map_(v, f));
+}
+/**
+ * Apply f to each element
+ *
+ * @tsplus fluent fncts.HashMap forEachWithIndex
+ */
+
+
+function forEachWithIndex_1(map, f) {
+  foldLeftWithIndex_1(map, undefined, (key, _, value) => f(key, value, map));
+}
+/**
+ * Apply f to each element
+ *
+ * @tsplus fluent fncts.HashMap forEach
+ */
+
+
+function forEach_1(map, f) {
+  return forEachWithIndex_1(map, (_, v, m) => f(v, m));
+}
+/**
+ * Maps over the map entries
+ *
+ * @tsplus fluent fncts.HashMap mapWithIndex
+ */
+
+
+function mapWithIndex_1(fa, f) {
+  return foldLeftWithIndex_1(fa, makeWith_1(fa.config), (k, z, v) => set_1(z, k, f(k, v)));
+}
+/**
+ * Maps over the map entries
+ *
+ * @tsplus fluent fncts.HashMap map
+ */
+
+
+function map_(fa, f) {
+  return mapWithIndex_1(fa, (_, a) => f(a));
+}
+/**
+ * Chain over the map entries, the hash and equal of the 2 maps has to be the same
+ *
+ * @tsplus fluent fncts.HashMap flatMapWithIndex
+ */
+
+
+function flatMapWithIndex_1(ma, f) {
+  return foldLeftWithIndex_1(ma, makeWith_1(ma.config), (k, z, v) => mutate_1(z, m => {
+    forEachWithIndex_1(f(k, v), (k1, a1) => {
+      set_1(m, k1, a1);
+    });
+  }));
+}
+/**
+ * Chain over the map entries, the hash and equal of the 2 maps has to be the same
+ *
+ * @tsplus fluent fncts.HashMap flatMap
+ */
+
+
+function flatMap_(ma, f) {
+  return flatMapWithIndex_1(ma, (_, a) => f(a));
+}
+/**
+ * Removes values that are `Nothing`
+ *
+ * @tsplus getter fncts.HashMap compact
+ */
+
+
+function compact_1(map) {
+  return filterMap_1(map, tsplus_module_8.identity);
+}
+/**
+ * Removes `Either` values into two separate `HashMaps`
+ *
+ * @tsplus getter fncts.HashMap separate
+ */
+
+
+function separate_1(map) {
+  return partitionMap_1(map, tsplus_module_8.identity);
+}
+/**
+ * Filter out None and map
+ *
+ * @tsplus fluent fncts.HashMap filterMapWithIndex
+ */
+
+
+function filterMapWithIndex_1(map, f) {
+  return mutate_1(makeWith_1(map.config), m => {
+    for (const [k, a] of map) {
+      const o = f(k, a);
+
+      if (tsplus_module_3.isJust(o)) {
+        set_1(m, k, o.value);
+      }
+    }
+  });
+}
+/**
+ * Filter out None and map
+ *
+ * @tsplus fluent fncts.HashMap filterMap
+ */
+
+
+function filterMap_1(map, f) {
+  return filterMapWithIndex_1(map, (_, a) => f(a));
+}
+
+function filterWithIndex_1(map, predicate) {
+  return mutate_1(makeWith_1(map.config), m => {
+    for (const [k, a] of map) {
+      if (predicate(k, a)) {
+        set_1(m, k, a);
+      }
+    }
+  });
+}
+
+function filter_(map, predicate) {
+  return filterWithIndex_1(map, (_, a) => predicate(a));
+}
+/**
+ * @tsplus fluent fncts.HashMap partitionMapWithIndex
+ */
+
+
+function partitionMapWithIndex_1(map, f) {
+  const left = beginMutation_1(makeWith_1(map.config));
+  const right = beginMutation_1(makeWith_1(map.config));
+  forEachWithIndex_1(map, (k, v) => {
+    tsplus_module_9.match_(f(k, v), a => {
+      set_1(left, k, a);
+    }, b => {
+      set_1(right, k, b);
+    });
+  });
+  return [endMutation_1(left), endMutation_1(right)];
+}
+/**
+ * @tsplus fluent fncts.HashMap partitionMap
+ */
+
+
+function partitionMap_1(map, f) {
+  return partitionMapWithIndex_1(map, (_, a) => f(a));
+}
+
+function partitionWithIndex_1(map, predicate) {
+  const left = beginMutation_1(makeWith_1(map.config));
+  const right = beginMutation_1(makeWith_1(map.config));
+  forEachWithIndex_1(map, (k, v) => {
+    if (predicate(k, v)) {
+      set_1(right, k, v);
+    } else {
+      set_1(left, k, v);
+    }
+  });
+  return [endMutation_1(left), endMutation_1(right)];
+}
+
+function partition_(map, predicate) {
+  return partitionWithIndex_1(map, (_, a) => predicate(a));
+}
+/**
+ * Reduce a state over the map entries
+ *
+ * @tsplus fluent fncts.HashMap foldLeftWithIndex
+ */
+
+
+function foldLeftWithIndex_1(map, z, f) {
+  const root = map.root;
+  if (root._tag === "LeafNode") return tsplus_module_3.isJust(root.value) ? f(root.key, z, root.value.value) : z;
+
+  if (root._tag === "EmptyNode") {
+    return z;
+  }
+
+  const toVisit = [root.children];
+  let children;
+  let acc = z;
+
+  while (children = toVisit.pop()) {
+    for (let i = 0, len = children.length; i < len;) {
+      const child = children[i++];
+
+      if (child && !(0, _internal.isEmptyNode)(child)) {
+        if (child._tag === "LeafNode") {
+          if (tsplus_module_3.isJust(child.value)) {
+            // eslint-disable-next-line no-param-reassign
+            acc = f(child.key, acc, child.value.value);
+          }
+        } else {
+          toVisit.push(child.children);
+        }
+      }
+    }
+  }
+
+  return acc;
+}
+/**
+ * Reduce a state over the map entries
+ *
+ * @tsplus fluent fncts.HashMap foldLeft
+ */
+
+
+function foldLeft_(map, z, f) {
+  return foldLeftWithIndex_1(map, z, (_, b, a) => f(b, a));
+}
+
+const traverseWithIndex_ = /*#__PURE__*/P.mkTraverseWithIndex_()(() => A => (ta, f) => foldLeftWithIndex_1(ta, A.pure(makeWith_1(ta.config)), (k, b, a) => A.zipWith_(b, f(k, a), (map, b) => set_1(map, k, b))));
+exports.traverseWithIndex_ = traverseWithIndex_;
+
+const traverseWithIndex = A => {
+  const traverseWithIndexA_ = traverseWithIndex_(A);
+  return f => ta => traverseWithIndexA_(ta, f);
+};
+/**
+ * @tsplus getter fncts.HashMap traverseWithIndex
+ */
+
+
+exports.traverseWithIndex = traverseWithIndex;
+
+const traverseWithIndexSelf_1 = self => A => f => traverseWithIndex_(A)(self, f);
+
+const traverseWithIndexSelf = traverseWithIndexSelf_1;
+exports.traverseWithIndexSelf = traverseWithIndexSelf;
+
+const traverse_ = A => {
+  const traverseWithIndexA_ = traverseWithIndex_(A);
+  return (ta, f) => traverseWithIndexA_(ta, (_, a) => f(a));
+};
+
+exports.traverse_ = traverse_;
+
+const traverse = A => {
+  const traverseWithIndexA_ = traverseWithIndex_(A);
+  return f => ta => traverseWithIndexA_(ta, (_, a) => f(a));
+};
+/**
+ * @tsplus fluent fncts.HashMap unsafeGet
+ */
+
+
+exports.traverse = traverse;
+
+function unsafeGet_(self, key) {
+  return tsplus_module_7.toUndefined(getHash_1(self, key, self.config.hash(key)));
+}
+/**
+ * @tsplus getter fncts.HashMap traverse
+ */
+
+
+const traverseSelf = self => A => f => traverseWithIndex_(A)(self, (_, a) => f(a));
+
+exports.traverseSelf = traverseSelf;
+
+const witherWithIndex_ = A => (wa, f) => A.map_(traverseWithIndexSelf_1(wa)(A)(f), compact_1);
+
+exports.witherWithIndex_ = witherWithIndex_;
+
+const witherWithIndex = A => {
+  const witherWithIndexA_ = witherWithIndex_(A);
+  return f => ta => witherWithIndexA_(ta, f);
+};
+/**
+ * @tsplus getter fncts.HashMap witherWithIndex
+ */
+
+
+exports.witherWithIndex = witherWithIndex;
+
+const witherWithIndexSelf_1 = self => A => f => witherWithIndex_(A)(self, f);
+
+const witherWithIndexSelf = witherWithIndexSelf_1;
+exports.witherWithIndexSelf = witherWithIndexSelf;
+
+const wither_ = A => {
+  const witherWithIndexA_ = witherWithIndex_(A);
+  return (wa, f) => witherWithIndexA_(wa, (_, a) => f(a));
+};
+
+exports.wither_ = wither_;
+
+const wither = A => {
+  const witherWithIndexA_ = witherWithIndex_(A);
+  return f => wa => witherWithIndexA_(wa, (_, a) => f(a));
+};
+/**
+ * @tsplus getter fncts.HashMap wither
+ */
+
+
+exports.wither = wither;
+
+const witherSelf = self => A => f => witherWithIndexSelf_1(self)(A)((_, a) => f(a));
+
+exports.witherSelf = witherSelf;
+
+const wiltWithIndex_ = A => {
+  const traverseWithIndexA_ = traverseWithIndex_(A);
+  return (wa, f) => A.map(separate_1)(traverseWithIndexA_(wa, f));
+};
+
+exports.wiltWithIndex_ = wiltWithIndex_;
+
+const wiltWithIndex = A => {
+  const wiltWithIndexA_ = wiltWithIndex_(A);
+  return f => wa => wiltWithIndexA_(wa, f);
+};
+/**
+ * @tsplus getter fncts.HashMap wiltWithIndex
+ */
+
+
+exports.wiltWithIndex = wiltWithIndex;
+
+const wiltWithIndexSelf_1 = self => A => f => wiltWithIndex_(A)(self, f);
+
+const wiltWithIndexSelf = wiltWithIndexSelf_1;
+exports.wiltWithIndexSelf = wiltWithIndexSelf;
+
+const wilt_ = A => {
+  const wiltWithIndexA_ = wiltWithIndex_(A);
+  return (wa, f) => wiltWithIndexA_(wa, (_, a) => f(a));
+};
+
+exports.wilt_ = wilt_;
+
+const wilt = A => {
+  const wiltWithIndexA_ = wiltWithIndex_(A);
+  return f => wa => wiltWithIndexA_(wa, (_, a) => f(a));
+};
+/**
+ * @tsplus getter fncts.HashMap wilt
+ */
+
+
+exports.wilt = wilt;
+
+const wiltSelf = self => A => f => wiltWithIndexSelf_1(self)(A)((_, a) => f(a));
+/**
+ * @tsplus fluent fncts.HashMap unionWith
+ */
+
+
+exports.wiltSelf = wiltSelf;
+
+function unionWith_(self, that, f) {
+  return mutate_1(self, m => {
+    for (const [k, a] of that) {
+      modify_1(m, k, v => tsplus_module_10.match_(v, () => tsplus_module_4.just(a), a0 => tsplus_module_4.just(f(a0, a))));
+    }
+  });
+}
+/**
+ * @tsplus fluent fncts.HashMap union
+ */
+
+
+function union_(self, that) {
+  return mutate_1(self, m => {
+    for (const [k, a] of that) {
+      set_1(m, k, a);
+    }
+  });
+}
+/**
+ * @tsplus fluent fncts.HashMap pop
+ */
+
+
+function pop_(map, k) {
+  return tsplus_module_7.map_(get_1(map, k), a => [a, remove_1(map, k)]);
+}
+/*
+ * -------------------------------------------------------------------------------------------------
+ * internal
+ * -------------------------------------------------------------------------------------------------
+ */
+
+/**
+ * Set the root of the map
+ */
+
+
+function setTree(map, newRoot, newSize) {
+  if (map.editable) {
+    map.root = newRoot;
+    map.size = newSize;
+    return map;
+  }
+
+  return newRoot === map.root ? map : new tsplus_module_1.HashMap(map.editable, map.edit, map.config, newRoot, newSize);
+}
+/**
+ * Lookup the value for `key` in `map` using custom hash.
+ */
+
+
+function tryGetHash(map, key, hash) {
+  let node = map.root;
+  let shift = 0;
+  const keyEq = map.config.equals_; // eslint-disable-next-line no-constant-condition
+
+  while (true) {
+    switch (node._tag) {
+      case "LeafNode":
+        {
+          return keyEq(node.key, key) ? node.value : tsplus_module_4.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 ("key" in child && keyEq(child.key, key)) return child.value;
+            }
+          }
+
+          return tsplus_module_4.nothing();
+        }
+
+      case "IndexedNode":
+        {
+          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_4.nothing();
+        }
+
+      case "ArrayNode":
+        {
+          node = node.children[(0, _internal.hashFragment)(shift, hash)];
+
+          if (node) {
+            shift += _internal.SIZE;
+            break;
+          }
+
+          return tsplus_module_4.nothing();
+        }
+
+      default:
+        return tsplus_module_4.nothing();
+    }
+  }
+}
+//# sourceMappingURL=api.cjs.map