@fncts/base 0.0.20 → 0.0.21

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

@@ -3,36 +3,43 @@
 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._traverse = _traverse;
+exports._traverseWithIndex = void 0;
+exports._wilt = _wilt;
+exports._wiltWithIndex = void 0;
+exports._wither = _wither;
+exports.endMutation = exports.compact = exports.beginMutation = exports._witherWithIndex = void 0;
+exports.filter = filter;
+exports.filterWithIndex = exports.filterMapWithIndex = exports.filterMap = void 0;
+exports.flatMap = flatMap;
+exports.flatMapWithIndex = void 0;
+exports.foldLeft = foldLeft;
+exports.forEachWithIndex = exports.forEach = exports.foldLeftWithIndex = void 0;
 exports.fromFoldable = fromFoldable;
-exports.get_ = exports.getHash_ = void 0;
-exports.hasHash_ = hasHash_;
-exports.has_ = has_;
+exports.getHash = exports.get = void 0;
+exports.has = has;
+exports.hasHash = hasHash;
 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.makeWith = exports.makeDefault = void 0;
+exports.map = map;
+exports.mutate = exports.modifyHash = exports.modify = exports.mapWithIndex = void 0;
+exports.partition = partition;
+exports.partitionWithIndex = exports.partitionMapWithIndex = exports.partitionMap = void 0;
+exports.pop = pop;
+exports.remove = void 0;
+exports.removeMany = removeMany;
+exports.set = exports.separate = void 0;
 exports.toArray = toArray;
 exports.toList = toList;
 exports.toSetDefault = toSetDefault;
 exports.traverseWithIndex = exports.traverse = void 0;
-exports.unionWith_ = unionWith_;
-exports.union_ = union_;
-exports.unsafeGet_ = unsafeGet_;
-exports.update_ = update_;
+exports.union = union;
+exports.unionWith = unionWith;
+exports.unsafeGet = unsafeGet;
+exports.update = update;
 exports.values = values;
 exports.witherWithIndex = exports.wither = exports.wiltWithIndex = exports.wilt = void 0;
 
@@ -54,12 +61,12 @@ var tsplus_module_8 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require
 
 var tsplus_module_9 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Either/destructors"));
 
-var tsplus_module_10 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/typeclass/TraversableWithIndex"));
-
-var tsplus_module_11 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Maybe/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 _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); }
@@ -70,50 +77,56 @@ 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 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 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_;
+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;
+const _traverseWithIndex = _traverseWithIndex_1;
+exports._traverseWithIndex = _traverseWithIndex;
+const _witherWithIndex = _witherWithIndex_1;
+exports._witherWithIndex = _witherWithIndex;
+const _wiltWithIndex = _wiltWithIndex_1;
+exports._wiltWithIndex = _wiltWithIndex;
 
 /**
  * Does `map` contain any elements?
@@ -139,11 +152,11 @@ function makeWith_1(config) {
 
 
 function make(...items) {
-  return mutate_1(makeDefault_1(), map => {
+  return mutate_1(map => {
     for (const [key, value] of items) {
-      set_1(map, key, value);
+      set_1(key, value)(map);
     }
-  });
+  })(makeDefault_1());
 }
 /**
  * Make a new map that has randomly cached hash and structural equality
@@ -158,62 +171,70 @@ function makeDefault_1() {
 /**
  * Makes a new map from a Foldable of key-value pairs
  *
- * @tsplus fluent fncts.HashMapOps fromFoldable
+ * @tsplus pipeable 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);
+    return F.foldLeft(makeWith_1(config), (b, [k, a]) => {
+      const oa = get_1(k)(b);
 
       if (tsplus_module_3.isJust(oa)) {
-        return set_1(b, k, S.combine(oa.value, a));
+        return set_1(k, S.combine(oa.value, a))(b);
       } else {
-        return set_1(b, k, a);
+        return set_1(k, a)(b);
       }
-    });
+    })(fka);
   };
 }
 /**
  * Lookup the value for `key` in `map` using custom hash.
  *
- * @tsplus fluent fncts.HashMap getHash
+ * @tsplus pipeable fncts.HashMap getHash
  */
 
 
-function getHash_1(map, key, hash) {
-  return tryGetHash(map, key, hash);
+function getHash_1(key, hash) {
+  return map => {
+    return tryGetHash(map, key, hash);
+  };
 }
 /**
  * Lookup the value for `key` in `map` using internal hash function.
  *
- * @tsplus fluent fncts.HashMap get
+ * @tsplus pipeable fncts.HashMap get
  */
 
 
-function get_1(map, key) {
-  return tryGetHash(map, key, map.config.hash(key));
+function get_1(key) {
+  return map => {
+    return tryGetHash(map, key, map.config.hash(key));
+  };
 }
 /**
  * Does an entry exist for `key` in `map`? Uses custom `hash`.
  *
- * @tsplus fluent fncts.HashMap hashHash
+ * @tsplus pipeable fncts.HashMap hashHash
  */
 
 
-function hasHash_(map, key, hash) {
-  return tsplus_module_3.isJust(tryGetHash(map, key, hash));
+function hasHash(key, hash) {
+  return map => {
+    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
+ * @tsplus pipeable fncts.HashMap has
  */
 
 
-function has_(map, key) {
-  return tsplus_module_3.isJust(tryGetHash(map, key, map.config.hash(key)));
+function has(key) {
+  return map => {
+    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.
@@ -224,16 +245,18 @@ function has_(map, key) {
  * `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
+ * @tsplus pipeable fncts.HashMap modifyHash
  */
 
 
-function modifyHash_1(map, key, hash, f) {
-  const size = {
-    value: map.size
+function modifyHash_1(key, hash, f) {
+  return map => {
+    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);
   };
-  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.
@@ -244,46 +267,54 @@ function modifyHash_1(map, key, hash, f) {
  * `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
+ * @tsplus pipeable fncts.HashMap modify
  */
 
 
-function modify_1(map, key, f) {
-  return modifyHash_1(map, key, map.config.hash(key), f);
+function modify_1(key, f) {
+  return map => {
+    return modifyHash_1(key, map.config.hash(key), f)(map);
+  };
 }
 /**
  * Store `value` for `key` in `map` using internal hash function.
  *
- * @tsplus fluent fncts.HashMap set
+ * @tsplus pipeable fncts.HashMap set
  */
 
 
-function set_1(map, key, value) {
-  return modify_1(map, key, () => tsplus_module_4.just(value));
+function set_1(key, value) {
+  return map => {
+    return modify_1(key, () => tsplus_module_4.just(value))(map);
+  };
 }
 /**
  * Remove the entry for `key` in `map` using internal hash.
  *
- * @tsplus fluent fncts.HashMap remove
+ * @tsplus pipeable fncts.HashMap remove
  */
 
 
-function remove_1(map, key) {
-  return modify_1(map, key, () => tsplus_module_4.nothing());
+function remove_1(key) {
+  return map => {
+    return modify_1(key, () => tsplus_module_4.nothing())(map);
+  };
 }
 /**
  * Remove many keys
  *
- * @tsplus fluent fncts.HashMap removeMany
+ * @tsplus pipeable fncts.HashMap removeMany
  */
 
 
-function removeMany_(map, keys) {
-  return mutate_1(map, m => {
-    for (const k of keys) {
-      remove_1(m, k);
-    }
-  });
+function removeMany(keys) {
+  return map => {
+    return mutate_1(m => {
+      for (const k of keys) {
+        remove_1(k)(m);
+      }
+    })(map);
+  };
 }
 /**
  * Mark `map` as mutable.
@@ -309,14 +340,16 @@ function endMutation_1(map) {
 /**
  * Mutate `map` within the context of `f`.
  *
- * @tsplus fluent fncts.HashMap mutate
+ * @tsplus pipeable fncts.HashMap mutate
  */
 
 
-function mutate_1(map, f) {
-  const transient = beginMutation_1(map);
-  f(transient);
-  return endMutation_1(transient);
+function mutate_1(f) {
+  return map => {
+    const transient = beginMutation_1(map);
+    f(transient);
+    return endMutation_1(transient);
+  };
 }
 /**
  * Get an IterableIterator of the map keys
@@ -336,11 +369,11 @@ function keys(map) {
 
 
 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);
-    });
-  });
+  return tsplus_module_5.mutate(set => {
+    forEachWithIndex_1(k => {
+      tsplus_module_5.add(k)(set);
+    })(self);
+  })(tsplus_module_5.make(self.config));
 }
 /**
  * Get the set of values
@@ -350,11 +383,11 @@ function keySet(self) {
 
 
 function toSetDefault(map) {
-  return tsplus_module_5.mutate_(tsplus_module_5.makeDefault(), set => {
-    forEach_1(map, v => {
-      tsplus_module_5.add_(set, v);
-    });
-  });
+  return tsplus_module_5.mutate(set => {
+    forEach_1(v => {
+      tsplus_module_5.add(v)(set);
+    })(map);
+  })(tsplus_module_5.makeDefault());
 }
 /**
  * Get the set of values
@@ -365,9 +398,9 @@ function toSetDefault(map) {
 
 function toList(map) {
   const buffer = new tsplus_module_6.ListBuffer();
-  forEachWithIndex_1(map, (k, v) => {
+  forEachWithIndex_1((k, v) => {
     buffer.append([k, v]);
-  });
+  })(map);
   return buffer.toList;
 }
 /**
@@ -380,10 +413,10 @@ function toList(map) {
 function toArray(map) {
   const buffer = Array(map.size);
   let i = 0;
-  forEachWithIndex_1(map, (k, v) => {
+  forEachWithIndex_1((k, v) => {
     buffer[i] = [k, v];
     i++;
-  });
+  })(map);
   return buffer;
 }
 /**
@@ -399,76 +432,90 @@ function values(map) {
 /**
  * Update a value if exists
  *
- * @tsplus fluent fncts.HashMap update
+ * @tsplus pipeable fncts.HashMap update
  */
 
 
-function update_(map, key, f) {
-  return modify_1(map, key, v => tsplus_module_7.map_(v, f));
+function update(key, f) {
+  return map => {
+    return modify_1(key, v => tsplus_module_7.map(f)(v))(map);
+  };
 }
 /**
  * Apply f to each element
  *
- * @tsplus fluent fncts.HashMap forEachWithIndex
+ * @tsplus pipeable fncts.HashMap forEachWithIndex
  */
 
 
-function forEachWithIndex_1(map, f) {
-  foldLeftWithIndex_1(map, undefined, (key, _, value) => f(key, value, map));
+function forEachWithIndex_1(f) {
+  return map => {
+    foldLeftWithIndex_1(undefined, (key, _, value) => f(key, value, map))(map);
+  };
 }
 /**
  * Apply f to each element
  *
- * @tsplus fluent fncts.HashMap forEach
+ * @tsplus pipeable fncts.HashMap forEach
  */
 
 
-function forEach_1(map, f) {
-  return forEachWithIndex_1(map, (_, v, m) => f(v, m));
+function forEach_1(f) {
+  return map => {
+    return forEachWithIndex_1((_, v, m) => f(v, m))(map);
+  };
 }
 /**
  * Maps over the map entries
  *
- * @tsplus fluent fncts.HashMap mapWithIndex
+ * @tsplus pipeable 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)));
+function mapWithIndex_1(f) {
+  return fa => {
+    return foldLeftWithIndex_1(makeWith_1(fa.config), (k, z, v) => set_1(k, f(k, v))(z))(fa);
+  };
 }
 /**
  * Maps over the map entries
  *
- * @tsplus fluent fncts.HashMap map
+ * @tsplus pipeable fncts.HashMap map
  */
 
 
-function map_(fa, f) {
-  return mapWithIndex_1(fa, (_, a) => f(a));
+function map(f) {
+  return fa => {
+    return mapWithIndex_1((_, a) => f(a))(fa);
+  };
 }
 /**
  * Chain over the map entries, the hash and equal of the 2 maps has to be the same
  *
- * @tsplus fluent fncts.HashMap flatMapWithIndex
+ * @tsplus pipeable 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);
-    });
-  }));
+function flatMapWithIndex_1(f) {
+  return ma => {
+    return foldLeftWithIndex_1(makeWith_1(ma.config), (k, z, v) => mutate_1(m => {
+      forEachWithIndex_1((k1, a1) => {
+        set_1(k1, a1)(m);
+      })(f(k, v));
+    })(z))(ma);
+  };
 }
 /**
  * Chain over the map entries, the hash and equal of the 2 maps has to be the same
  *
- * @tsplus fluent fncts.HashMap flatMap
+ * @tsplus pipeable fncts.HashMap flatMap
  */
 
 
-function flatMap_(ma, f) {
-  return flatMapWithIndex_1(ma, (_, a) => f(a));
+function flatMap(f) {
+  return ma => {
+    return flatMapWithIndex_1((_, a) => f(a))(ma);
+  };
 }
 /**
  * Removes values that are `Nothing`
@@ -478,7 +525,7 @@ function flatMap_(ma, f) {
 
 
 function compact_1(map) {
-  return filterMap_1(map, tsplus_module_8.identity);
+  return filterMap_1(tsplus_module_8.identity)(map);
 }
 /**
  * Removes `Either` values into two separate `HashMaps`
@@ -488,179 +535,212 @@ function compact_1(map) {
 
 
 function separate_1(map) {
-  return partitionMap_1(map, tsplus_module_8.identity);
+  return partitionMap_1(tsplus_module_8.identity)(map);
 }
 /**
  * Filter out None and map
  *
- * @tsplus fluent fncts.HashMap filterMapWithIndex
+ * @tsplus pipeable 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);
+function filterMapWithIndex_1(f) {
+  return map => {
+    return mutate_1(m => {
+      for (const [k, a] of map) {
+        const o = f(k, a);
 
-      if (tsplus_module_3.isJust(o)) {
-        set_1(m, k, o.value);
+        if (tsplus_module_3.isJust(o)) {
+          set_1(k, o.value)(m);
+        }
       }
-    }
-  });
+    })(makeWith_1(map.config));
+  };
 }
 /**
  * Filter out None and map
  *
- * @tsplus fluent fncts.HashMap filterMap
+ * @tsplus pipeable fncts.HashMap filterMap
  */
 
 
-function filterMap_1(map, f) {
-  return filterMapWithIndex_1(map, (_, a) => f(a));
+function filterMap_1(f) {
+  return map => {
+    return filterMapWithIndex_1((_, a) => f(a))(map);
+  };
 }
 
-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 filterWithIndex_1(predicate) {
+  return map => {
+    return mutate_1(m => {
+      for (const [k, a] of map) {
+        if (predicate(k, a)) {
+          set_1(k, a)(m);
+        }
       }
-    }
-  });
+    })(makeWith_1(map.config));
+  };
 }
 
-function filter_(map, predicate) {
-  return filterWithIndex_1(map, (_, a) => predicate(a));
+function filter(predicate) {
+  return map => {
+    return filterWithIndex_1((_, a) => predicate(a))(map);
+  };
 }
 /**
- * @tsplus fluent fncts.HashMap partitionMapWithIndex
+ * @tsplus pipeable 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)];
+function partitionMapWithIndex_1(f) {
+  return map => {
+    const left = beginMutation_1(makeWith_1(map.config));
+    const right = beginMutation_1(makeWith_1(map.config));
+    forEachWithIndex_1((k, v) => {
+      tsplus_module_9.match(a => {
+        set_1(k, a)(left);
+      }, b => {
+        set_1(k, b)(right);
+      })(f(k, v));
+    })(map);
+    return [endMutation_1(left), endMutation_1(right)];
+  };
 }
 /**
- * @tsplus fluent fncts.HashMap partitionMap
+ * @tsplus pipeable fncts.HashMap partitionMap
  */
 
 
-function partitionMap_1(map, f) {
-  return partitionMapWithIndex_1(map, (_, a) => f(a));
+function partitionMap_1(f) {
+  return map => {
+    return partitionMapWithIndex_1((_, a) => f(a))(map);
+  };
 }
 
-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 partitionWithIndex_1(predicate) {
+  return map => {
+    const left = beginMutation_1(makeWith_1(map.config));
+    const right = beginMutation_1(makeWith_1(map.config));
+    forEachWithIndex_1((k, v) => {
+      if (predicate(k, v)) {
+        set_1(k, v)(right);
+      } else {
+        set_1(k, v)(left);
+      }
+    })(map);
+    return [endMutation_1(left), endMutation_1(right)];
+  };
 }
 
-function partition_(map, predicate) {
-  return partitionWithIndex_1(map, (_, a) => predicate(a));
+function partition(predicate) {
+  return map => {
+    return partitionWithIndex_1((_, a) => predicate(a))(map);
+  };
 }
 /**
  * Reduce a state over the map entries
  *
- * @tsplus fluent fncts.HashMap foldLeftWithIndex
+ * @tsplus pipeable 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;
+function foldLeftWithIndex_1(z, f) {
+  return map => {
+    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;
-  }
+    if (root._tag === "EmptyNode") {
+      return z;
+    }
 
-  const toVisit = [root.children];
-  let children;
-  let acc = 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++];
+    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);
+        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);
           }
-        } else {
-          toVisit.push(child.children);
         }
       }
     }
-  }
 
-  return acc;
+    return acc;
+  };
 }
 /**
  * Reduce a state over the map entries
  *
- * @tsplus fluent fncts.HashMap foldLeft
+ * @tsplus pipeable fncts.HashMap foldLeft
  */
 
 
-function foldLeft_(map, z, f) {
-  return foldLeftWithIndex_1(map, z, (_, b, a) => f(b, a));
+function foldLeft(z, f) {
+  return map => {
+    return foldLeftWithIndex_1(z, (_, b, a) => f(b, a))(map);
+  };
 }
-/**
- * @tsplus getter fncts.HashMap traverseWithIndex
- */
-
 
-const traverseWithIndex_1 = /*#__PURE__*/tsplus_module_10.mkTraverseWithIndex_()(() => ta => G => f => foldLeftWithIndex_1(ta, G.pure(makeWith_1(ta.config)), (k, b, a) => G.zipWith(b, f(k, a), (map, b) => set_1(map, k, b))));
-const traverseWithIndex = traverseWithIndex_1;
+function _traverseWithIndex_1(self) {
+  return G => f => foldLeftWithIndex_1(G.pure(makeWith_1(self.config)), (k, b, a) => G.zipWith(f(k, a), (map, b) => set_1(k, b)(map))(b))(self);
+}
 /**
  * @tsplus getter fncts.HashMap traverse
  */
 
+
+function _traverse(self) {
+  return G => f => _traverseWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+const traverseWithIndex = G => f => ta => _traverseWithIndex_1(ta)(G)(f);
+
 exports.traverseWithIndex = traverseWithIndex;
 
-const traverse = ta => G => f => traverseWithIndex_1(ta)(G)((_, a) => f(a));
+const traverse = G => f => ta => _traverseWithIndex_1(ta)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.HashMap unsafeGet
+ * @tsplus pipeable fncts.HashMap unsafeGet
  */
 
 
 exports.traverse = traverse;
 
-function unsafeGet_(self, key) {
-  return tsplus_module_7.toUndefined(getHash_1(self, key, self.config.hash(key)));
+function unsafeGet(key) {
+  return self => {
+    return tsplus_module_7.toUndefined(getHash_1(key, self.config.hash(key))(self));
+  };
 }
 /**
  * @tsplus getter fncts.HashMap witherWithIndex
  */
 
 
-const witherWithIndex_1 = wa => G => f => G.map(traverseWithIndex_1(wa)(G)(f), compact_1);
-
-const witherWithIndex = witherWithIndex_1;
+function _witherWithIndex_1(self) {
+  return G => f => G.map(compact_1)(_traverseWithIndex_1(self)(G)(f));
+}
 /**
  * @tsplus getter fncts.HashMap wither
  */
 
+
+function _wither(self) {
+  return G => f => _witherWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+const witherWithIndex = G => f => wa => _witherWithIndex_1(wa)(G)(f);
+
 exports.witherWithIndex = witherWithIndex;
 
-const wither = wa => G => f => witherWithIndex_1(wa)(G)((_, a) => f(a));
+const wither = G => f => wa => _witherWithIndex_1(wa)(G)((_, a) => f(a));
 /**
  * @tsplus getter fncts.HashMap wiltWithIndex
  */
@@ -668,49 +748,62 @@ const wither = wa => G => f => witherWithIndex_1(wa)(G)((_, a) => f(a));
 
 exports.wither = wither;
 
-const wiltWithIndex_1 = wa => G => f => G.map(traverseWithIndex_1(wa)(G)(f), separate_1);
-
-const wiltWithIndex = wiltWithIndex_1;
+function _wiltWithIndex_1(self) {
+  return G => f => G.map(separate_1)(_traverseWithIndex_1(self)(G)(f));
+}
 /**
  * @tsplus getter fncts.HashMap wilt
  */
 
+
+function _wilt(self) {
+  return G => f => _wiltWithIndex_1(self)(G)((_, a) => f(a));
+}
+
+const wiltWithIndex = G => f => wa => _wiltWithIndex_1(wa)(G)(f);
+
 exports.wiltWithIndex = wiltWithIndex;
 
-const wilt = wa => G => f => wiltWithIndex_1(wa)(G)((_, a) => f(a));
+const wilt = G => f => wa => _wiltWithIndex_1(wa)(G)((_, a) => f(a));
 /**
- * @tsplus fluent fncts.HashMap unionWith
+ * @tsplus pipeable fncts.HashMap unionWith
  */
 
 
 exports.wilt = wilt;
 
-function unionWith_(self, that, f) {
-  return mutate_1(self, m => {
-    for (const [k, a] of that) {
-      modify_1(m, k, v => tsplus_module_11.match_(v, () => tsplus_module_4.just(a), a0 => tsplus_module_4.just(f(a0, a))));
-    }
-  });
+function unionWith(that, f) {
+  return self => {
+    return mutate_1(m => {
+      for (const [k, a] of that) {
+        modify_1(k, v => tsplus_module_10.match(() => tsplus_module_4.just(a), a0 => tsplus_module_4.just(f(a0, a)))(v))(m);
+      }
+    })(self);
+  };
 }
 /**
- * @tsplus fluent fncts.HashMap union
+ * @tsplus pipeable fncts.HashMap union
  */
 
 
-function union_(self, that) {
-  return mutate_1(self, m => {
-    for (const [k, a] of that) {
-      set_1(m, k, a);
-    }
-  });
+function union(that) {
+  return self => {
+    return mutate_1(m => {
+      for (const [k, a] of that) {
+        set_1(k, a)(m);
+      }
+    })(self);
+  };
 }
 /**
- * @tsplus fluent fncts.HashMap pop
+ * @tsplus pipeable fncts.HashMap pop
  */
 
 
-function pop_(map, k) {
-  return tsplus_module_7.map_(get_1(map, k), a => [a, remove_1(map, k)]);
+function pop(k) {
+  return map => {
+    return tsplus_module_7.map(a => [a, remove_1(k)(map)])(get_1(k)(map));
+  };
 }
 /*
  * -------------------------------------------------------------------------------------------------