@fncts/base 0.0.20 → 0.0.21

package/_src/collection/immutable/HashMap/api.ts

@@ -10,6 +10,7 @@ import {
   SIZE,
   toBitmap,
 } from "@fncts/base/collection/immutable/HashMap/internal";
+import { pipe } from "@fncts/base/data/function";
 import * as P from "@fncts/base/typeclass";
 
 /**
@@ -53,55 +54,66 @@ export function makeDefault<K, V>(): HashMap<K, V> {
 /**
  * Makes a new map from a Foldable of key-value pairs
  *
- * @tsplus fluent fncts.HashMapOps fromFoldable
+ * @tsplus pipeable fncts.HashMapOps fromFoldable
  */
 export function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>) {
   return <K_, Q, W, X, I, S, R, E>(fka: HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
-    return F.foldLeft(fka, makeWith(config), (b, [k, a]) => {
-      const oa = b.get(k);
-      if (oa.isJust()) {
-        return b.set(k, S.combine(oa.value, a));
-      } else {
-        return b.set(k, a);
-      }
-    });
+    return pipe(
+      fka,
+      F.foldLeft(makeWith(config), (b, [k, a]) => {
+        const oa = b.get(k);
+        if (oa.isJust()) {
+          return b.set(k, S.combine(oa.value, a));
+        } else {
+          return b.set(k, a);
+        }
+      }),
+    );
   };
 }
 
 /**
  * Lookup the value for `key` in `map` using custom hash.
  *
- * @tsplus fluent fncts.HashMap getHash
+ * @tsplus pipeable fncts.HashMap getHash
  */
-export function getHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): Maybe<V> {
-  return tryGetHash(map, key, hash);
+export function getHash<K>(key: K, hash: number) {
+  return <V>(map: HashMap<K, V>): Maybe<V> => {
+    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
  */
-export function get_<K, V>(map: HashMap<K, V>, key: K): Maybe<V> {
-  return tryGetHash(map, key, map.config.hash(key));
+export function get<K>(key: K) {
+  return <V>(map: HashMap<K, V>): Maybe<V> => {
+    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
  */
-export function hasHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): boolean {
-  return tryGetHash(map, key, hash).isJust();
+export function hasHash<K>(key: K, hash: number) {
+  return <V>(map: HashMap<K, V>): boolean => {
+    return tryGetHash(map, key, hash).isJust();
+  };
 }
 
 /**
  * Does an entry exist for `key` in `map`? Uses internal hash function.
  *
- * @tsplus fluent fncts.HashMap has
+ * @tsplus pipeable fncts.HashMap has
  */
-export function has_<K, V>(map: HashMap<K, V>, key: K): boolean {
-  return tryGetHash(map, key, map.config.hash(key)).isJust();
+export function has<K>(key: K) {
+  return <V>(map: HashMap<K, V>): boolean => {
+    return tryGetHash(map, key, map.config.hash(key)).isJust();
+  };
 }
 
 /**
@@ -113,12 +125,14 @@ export function has_<K, V>(map: HashMap<K, V>, key: K): boolean {
  * `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
  */
-export function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: number, f: UpdateFn<V>): HashMap<K, V> {
-  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);
+export function modifyHash<K, V>(key: K, hash: number, f: UpdateFn<V>) {
+  return (map: HashMap<K, V>): HashMap<K, V> => {
+    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);
+  };
 }
 
 /**
@@ -130,41 +144,49 @@ export function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: number, f: U
  * `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
  */
-export function modify_<K, V>(map: HashMap<K, V>, key: K, f: UpdateFn<V>): HashMap<K, V> {
-  return map.modifyHash(key, map.config.hash(key), f);
+export function modify<K, V>(key: K, f: UpdateFn<V>) {
+  return (map: HashMap<K, V>): HashMap<K, V> => {
+    return map.modifyHash(key, map.config.hash(key), f);
+  };
 }
 
 /**
  * Store `value` for `key` in `map` using internal hash function.
  *
- * @tsplus fluent fncts.HashMap set
+ * @tsplus pipeable fncts.HashMap set
  */
-export function set_<K, V>(map: HashMap<K, V>, key: K, value: V): HashMap<K, V> {
-  return map.modify(key, () => Just(value));
+export function set<K, V>(key: K, value: V) {
+  return (map: HashMap<K, V>): HashMap<K, V> => {
+    return map.modify(key, () => Just(value));
+  };
 }
 
 /**
  * Remove the entry for `key` in `map` using internal hash.
  *
- * @tsplus fluent fncts.HashMap remove
+ * @tsplus pipeable fncts.HashMap remove
  */
-export function remove_<K, V>(map: HashMap<K, V>, key: K): HashMap<K, V> {
-  return map.modify(key, () => Nothing());
+export function remove<K>(key: K) {
+  return <V>(map: HashMap<K, V>): HashMap<K, V> => {
+    return map.modify(key, () => Nothing());
+  };
 }
 
 /**
  * Remove many keys
  *
- * @tsplus fluent fncts.HashMap removeMany
+ * @tsplus pipeable fncts.HashMap removeMany
  */
-export function removeMany_<K, V>(map: HashMap<K, V>, keys: Iterable<K>): HashMap<K, V> {
-  return mutate_(map, (m) => {
-    for (const k of keys) {
-      m.remove(k);
-    }
-  });
+export function removeMany<K>(keys: Iterable<K>) {
+  return <V>(map: HashMap<K, V>): HashMap<K, V> => {
+    return map.mutate((m) => {
+      for (const k of keys) {
+        m.remove(k);
+      }
+    });
+  };
 }
 
 /**
@@ -189,12 +211,14 @@ export function endMutation<K, V>(map: HashMap<K, V>): HashMap<K, V> {
 /**
  * Mutate `map` within the context of `f`.
  *
- * @tsplus fluent fncts.HashMap mutate
+ * @tsplus pipeable fncts.HashMap mutate
  */
-export function mutate_<K, V>(map: HashMap<K, V>, f: (map: HashMap<K, V>) => void): HashMap<K, V> {
-  const transient = map.beginMutation;
-  f(transient);
-  return transient.endMutation;
+export function mutate<K, V>(f: (map: HashMap<K, V>) => void) {
+  return (map: HashMap<K, V>): HashMap<K, V> => {
+    const transient = map.beginMutation;
+    f(transient);
+    return transient.endMutation;
+  };
 }
 
 /**
@@ -272,70 +296,84 @@ export function values<K, V>(map: HashMap<K, V>): IterableIterator<V> {
 /**
  * Update a value if exists
  *
- * @tsplus fluent fncts.HashMap update
+ * @tsplus pipeable fncts.HashMap update
  */
-export function update_<K, V>(map: HashMap<K, V>, key: K, f: (v: V) => V): HashMap<K, V> {
-  return map.modify(key, (v) => v.map(f));
+export function update<K, V>(key: K, f: (v: V) => V) {
+  return (map: HashMap<K, V>): HashMap<K, V> => {
+    return map.modify(key, (v) => v.map(f));
+  };
 }
 
 /**
  * Apply f to each element
  *
- * @tsplus fluent fncts.HashMap forEachWithIndex
+ * @tsplus pipeable fncts.HashMap forEachWithIndex
  */
-export function forEachWithIndex_<K, V>(map: HashMap<K, V>, f: (k: K, v: V, m: HashMap<K, V>) => void): void {
-  map.foldLeftWithIndex(undefined as void, (key, _, value) => f(key, value, map));
+export function forEachWithIndex<K, V>(f: (k: K, v: V, m: HashMap<K, V>) => void) {
+  return (map: HashMap<K, V>): void => {
+    map.foldLeftWithIndex(undefined as void, (key, _, value) => f(key, value, map));
+  };
 }
 
 /**
  * Apply f to each element
  *
- * @tsplus fluent fncts.HashMap forEach
+ * @tsplus pipeable fncts.HashMap forEach
  */
-export function forEach_<K, V>(map: HashMap<K, V>, f: (v: V, m: HashMap<K, V>) => void): void {
-  return map.forEachWithIndex((_, v, m) => f(v, m));
+export function forEach<K, V>(f: (v: V, m: HashMap<K, V>) => void) {
+  return (map: HashMap<K, V>): void => {
+    return map.forEachWithIndex((_, v, m) => f(v, m));
+  };
 }
 
 /**
  * Maps over the map entries
  *
- * @tsplus fluent fncts.HashMap mapWithIndex
+ * @tsplus pipeable fncts.HashMap mapWithIndex
  */
-export function mapWithIndex_<K, V, A>(fa: HashMap<K, V>, f: (k: K, v: V) => A): HashMap<K, A> {
-  return fa.foldLeftWithIndex(makeWith<K, A>(fa.config), (k, z, v) => z.set(k, f(k, v)));
+export function mapWithIndex<K, V, A>(f: (k: K, v: V) => A) {
+  return (fa: HashMap<K, V>): HashMap<K, A> => {
+    return fa.foldLeftWithIndex(makeWith<K, A>(fa.config), (k, z, v) => z.set(k, f(k, v)));
+  };
 }
 
 /**
  * Maps over the map entries
  *
- * @tsplus fluent fncts.HashMap map
+ * @tsplus pipeable fncts.HashMap map
  */
-export function map_<K, V, A>(fa: HashMap<K, V>, f: (v: V) => A): HashMap<K, A> {
-  return fa.mapWithIndex((_, a) => f(a));
+export function map<V, A>(f: (v: V) => A) {
+  return <K>(fa: HashMap<K, V>): HashMap<K, A> => {
+    return fa.mapWithIndex((_, 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
+ * @tsplus pipeable fncts.HashMap flatMapWithIndex
  */
-export function flatMapWithIndex_<K, V, A>(ma: HashMap<K, V>, f: (k: K, v: V) => HashMap<K, A>): HashMap<K, A> {
-  return ma.foldLeftWithIndex(makeWith<K, A>(ma.config), (k, z, v) =>
-    z.mutate((m) => {
-      f(k, v).forEachWithIndex((k1, a1) => {
-        m.set(k1, a1);
-      });
-    }),
-  );
+export function flatMapWithIndex<K, V, A>(f: (k: K, v: V) => HashMap<K, A>) {
+  return (ma: HashMap<K, V>): HashMap<K, A> => {
+    return ma.foldLeftWithIndex(makeWith<K, A>(ma.config), (k, z, v) =>
+      z.mutate((m) => {
+        f(k, v).forEachWithIndex((k1, a1) => {
+          m.set(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
+ * @tsplus pipeable fncts.HashMap flatMap
  */
-export function flatMap_<K, V, A>(ma: HashMap<K, V>, f: (v: V) => HashMap<K, A>): HashMap<K, A> {
-  return ma.flatMapWithIndex((_, a) => f(a));
+export function flatMap<K, V, A>(f: (v: V) => HashMap<K, A>) {
+  return (ma: HashMap<K, V>): HashMap<K, A> => {
+    return ma.flatMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
@@ -359,254 +397,330 @@ export function separate<K, A, B>(map: HashMap<K, Either<A, B>>): readonly [Hash
 /**
  * Filter out None and map
  *
- * @tsplus fluent fncts.HashMap filterMapWithIndex
+ * @tsplus pipeable fncts.HashMap filterMapWithIndex
  */
-export function filterMapWithIndex_<K, A, B>(map: HashMap<K, A>, f: (k: K, a: A) => Maybe<B>): HashMap<K, B> {
-  return makeWith<K, B>(map.config).mutate((m) => {
-    for (const [k, a] of map) {
-      const o = f(k, a);
-      if (o.isJust()) {
-        m.set(k, o.value);
+export function filterMapWithIndex<K, A, B>(f: (k: K, a: A) => Maybe<B>) {
+  return (map: HashMap<K, A>): HashMap<K, B> => {
+    return makeWith<K, B>(map.config).mutate((m) => {
+      for (const [k, a] of map) {
+        const o = f(k, a);
+        if (o.isJust()) {
+          m.set(k, o.value);
+        }
       }
-    }
-  });
+    });
+  };
 }
 
 /**
  * Filter out None and map
  *
- * @tsplus fluent fncts.HashMap filterMap
+ * @tsplus pipeable fncts.HashMap filterMap
  */
-export function filterMap_<K, A, B>(map: HashMap<K, A>, f: (a: A) => Maybe<B>): HashMap<K, B> {
-  return map.filterMapWithIndex((_, a) => f(a));
+export function filterMap<A, B>(f: (a: A) => Maybe<B>) {
+  return <K>(map: HashMap<K, A>): HashMap<K, B> => {
+    return map.filterMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
  * Filter out by predicate
  *
- * @tsplus fluent fncts.HashMap filterWithIndex
+ * @tsplus pipeable fncts.HashMap filterWithIndex
  */
-export function filterWithIndex_<K, A, B extends A>(
-  map: HashMap<K, A>,
+export function filterWithIndex<K, A, B extends A>(
   refinement: RefinementWithIndex<K, A, B>,
-): HashMap<K, B>;
-export function filterWithIndex_<K, A>(map: HashMap<K, A>, predicate: PredicateWithIndex<K, A>): HashMap<K, A>;
-export function filterWithIndex_<K, A>(map: HashMap<K, A>, predicate: PredicateWithIndex<K, A>): HashMap<K, A> {
-  return makeWith<K, A>(map.config).mutate((m) => {
-    for (const [k, a] of map) {
-      if (predicate(k, a)) {
-        m.set(k, a);
+): (map: HashMap<K, A>) => HashMap<K, B>;
+export function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>): (map: HashMap<K, A>) => HashMap<K, A>;
+export function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>) {
+  return (map: HashMap<K, A>): HashMap<K, A> => {
+    return makeWith<K, A>(map.config).mutate((m) => {
+      for (const [k, a] of map) {
+        if (predicate(k, a)) {
+          m.set(k, a);
+        }
       }
-    }
-  });
+    });
+  };
 }
 
 /**
  * Filter out by predicate
  *
- * @tsplus fluent fncts.HashMap filter
+ * @tsplus pipeable fncts.HashMap filter
  */
-export function filter_<K, A, B extends A>(map: HashMap<K, A>, refinement: Refinement<A, B>): HashMap<K, B>;
-export function filter_<K, A>(map: HashMap<K, A>, predicate: Predicate<A>): HashMap<K, A>;
-export function filter_<K, A>(map: HashMap<K, A>, predicate: Predicate<A>): HashMap<K, A> {
-  return map.filterWithIndex((_, a) => predicate(a));
+export function filter<A, B extends A>(refinement: Refinement<A, B>): <K>(map: HashMap<K, A>) => HashMap<K, B>;
+export function filter<A>(predicate: Predicate<A>): <K>(map: HashMap<K, A>) => HashMap<K, A>;
+export function filter<A>(predicate: Predicate<A>) {
+  return <K>(map: HashMap<K, A>): HashMap<K, A> => {
+    return map.filterWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap partitionMapWithIndex
+ * @tsplus pipeable fncts.HashMap partitionMapWithIndex
  */
-export function partitionMapWithIndex_<K, V, A, B>(
-  map: HashMap<K, V>,
-  f: (i: K, a: V) => Either<A, B>,
-): readonly [HashMap<K, A>, HashMap<K, B>] {
-  const left  = makeWith<K, A>(map.config).beginMutation;
-  const right = makeWith<K, B>(map.config).beginMutation;
-
-  map.forEachWithIndex((k, v) => {
-    f(k, v).match(
-      (a) => {
-        left.set(k, a);
-      },
-      (b) => {
-        right.set(k, b);
-      },
-    );
-  });
-
-  return [left.endMutation, right.endMutation];
+export function partitionMapWithIndex<K, V, A, B>(f: (i: K, a: V) => Either<A, B>) {
+  return (map: HashMap<K, V>): readonly [HashMap<K, A>, HashMap<K, B>] => {
+    const left  = makeWith<K, A>(map.config).beginMutation;
+    const right = makeWith<K, B>(map.config).beginMutation;
+    map.forEachWithIndex((k, v) => {
+      f(k, v).match(
+        (a) => {
+          left.set(k, a);
+        },
+        (b) => {
+          right.set(k, b);
+        },
+      );
+    });
+    return [left.endMutation, right.endMutation];
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap partitionMap
+ * @tsplus pipeable fncts.HashMap partitionMap
  */
-export function partitionMap_<K, V, A, B>(
-  map: HashMap<K, V>,
-  f: (a: V) => Either<A, B>,
-): readonly [HashMap<K, A>, HashMap<K, B>] {
-  return map.partitionMapWithIndex((_, a) => f(a));
+export function partitionMap<V, A, B>(f: (a: V) => Either<A, B>) {
+  return <K>(map: HashMap<K, V>): readonly [HashMap<K, A>, HashMap<K, B>] => {
+    return map.partitionMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap partitionWithIndex
+ * @tsplus pipeable fncts.HashMap partitionWithIndex
  */
-export function partitionWithIndex_<K, V, B extends V>(
-  map: HashMap<K, V>,
+export function partitionWithIndex<K, V, B extends V>(
   refinement: RefinementWithIndex<K, V, B>,
-): readonly [HashMap<K, V>, HashMap<K, B>];
-export function partitionWithIndex_<K, V>(
-  map: HashMap<K, V>,
-  predicate: PredicateWithIndex<K, V>,
-): readonly [HashMap<K, V>, HashMap<K, V>];
-export function partitionWithIndex_<K, V>(
-  map: HashMap<K, V>,
+): (map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
+export function partitionWithIndex<K, V>(
   predicate: PredicateWithIndex<K, V>,
-): readonly [HashMap<K, V>, HashMap<K, V>] {
-  const left  = makeWith<K, V>(map.config).beginMutation;
-  const right = makeWith<K, V>(map.config).beginMutation;
-
-  map.forEachWithIndex((k, v) => {
-    if (predicate(k, v)) {
-      right.set(k, v);
-    } else {
-      left.set(k, v);
-    }
-  });
-
-  return [left.endMutation, right.endMutation];
+): (map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export function partitionWithIndex<K, V>(predicate: PredicateWithIndex<K, V>) {
+  return (map: HashMap<K, V>): readonly [HashMap<K, V>, HashMap<K, V>] => {
+    const left  = makeWith<K, V>(map.config).beginMutation;
+    const right = makeWith<K, V>(map.config).beginMutation;
+    map.forEachWithIndex((k, v) => {
+      if (predicate(k, v)) {
+        right.set(k, v);
+      } else {
+        left.set(k, v);
+      }
+    });
+    return [left.endMutation, right.endMutation];
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap partition
+ * @tsplus pipeable fncts.HashMap partition
  */
-export function partition_<K, V, B extends V>(
-  map: HashMap<K, V>,
+export function partition<V, B extends V>(
   refinement: Refinement<V, B>,
-): readonly [HashMap<K, V>, HashMap<K, B>];
-export function partition_<K, V>(map: HashMap<K, V>, predicate: Predicate<V>): readonly [HashMap<K, V>, HashMap<K, V>];
-export function partition_<K, V>(map: HashMap<K, V>, predicate: Predicate<V>): readonly [HashMap<K, V>, HashMap<K, V>] {
-  return map.partitionWithIndex((_, a) => predicate(a));
+): <K>(map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
+export function partition<V>(
+  predicate: Predicate<V>,
+): <K>(map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export function partition<V>(predicate: Predicate<V>) {
+  return <K>(map: HashMap<K, V>): readonly [HashMap<K, V>, HashMap<K, V>] => {
+    return map.partitionWithIndex((_, a) => predicate(a));
+  };
 }
 
 /**
  * Reduce a state over the map entries
  *
- * @tsplus fluent fncts.HashMap foldLeftWithIndex
+ * @tsplus pipeable fncts.HashMap foldLeftWithIndex
  */
-export function foldLeftWithIndex_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (k: K, z: Z, v: V) => Z): Z {
-  const root = map.root;
-  if (root._tag === "LeafNode") return root.value.isJust() ? 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 && !isEmptyNode(child)) {
-        if (child._tag === "LeafNode") {
-          if (child.value.isJust()) {
-            // eslint-disable-next-line no-param-reassign
-            acc = f(child.key, acc, child.value.value);
+export function foldLeftWithIndex<K, V, Z>(z: Z, f: (k: K, z: Z, v: V) => Z) {
+  return (map: HashMap<K, V>): Z => {
+    const root = map.root;
+    if (root._tag === "LeafNode") return root.value.isJust() ? 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 && !isEmptyNode(child)) {
+          if (child._tag === "LeafNode") {
+            if (child.value.isJust()) {
+              // 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
  */
-export function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): Z {
-  return map.foldLeftWithIndex(z, (_, b, a) => f(b, a));
+export function foldLeft<V, Z>(z: Z, f: (z: Z, v: V) => Z) {
+  return <K>(map: HashMap<K, V>): Z => {
+    return map.foldLeftWithIndex(z, (_, b, a) => f(b, a));
+  };
 }
 
 /**
  * @tsplus getter fncts.HashMap traverseWithIndex
  */
-export const traverseWithIndex = P.TraversableWithIndex.makeTraverseWithIndex<HashMapF>()(
-  () => (ta) => (G) => (f) =>
-    ta.foldLeftWithIndex(G.pure(makeWith(ta.config)), (k, b, a) => G.zipWith(b, f(k, a), (map, b) => map.set(k, b))),
-);
+export function _traverseWithIndex<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B>(
+  f: (i: K, a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, B>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, HashMap<K, B>>;
+export function _traverseWithIndex<K, A>(
+  self: HashMap<K, A>,
+): <G>(G: P.Applicative<HKT.F<G>>) => <B>(f: (i: K, a: A) => HKT.FK1<G, B>) => HKT.FK1<G, HashMap<K, B>> {
+  return (G) => (f) =>
+    self.foldLeftWithIndex(G.pure(HashMap.makeWith(self.config)), (k, b, a) =>
+      pipe(
+        b,
+        G.zipWith(f(k, a), (map, b) => map.set(k, b)),
+      ),
+    );
+}
 
 /**
  * @tsplus getter fncts.HashMap traverse
  */
-export const traverse: P.Traversable<HashMapF>["traverse"] = (ta) => (G) => (f) =>
+export function _traverse<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B>(
+  f: (a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, B>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, HashMap<K, B>> {
+  return (G) => (f) => self.traverseWithIndex(G)((_, a) => f(a));
+}
+
+export const traverseWithIndex: P.TraversableWithIndex<HashMapF>["traverseWithIndex"] = (G) => (f) => (ta) =>
+  ta.traverseWithIndex(G)(f);
+
+export const traverse: P.Traversable<HashMapF>["traverse"] = (G) => (f) => (ta) =>
   ta.traverseWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.HashMap unsafeGet
+ * @tsplus pipeable fncts.HashMap unsafeGet
  */
-export function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined {
-  return self.getHash(key, self.config.hash(key)).value;
+export function unsafeGet<K>(key: K) {
+  return <V>(self: HashMap<K, V>): V | undefined => {
+    return self.getHash(key, self.config.hash(key)).value;
+  };
 }
 
 /**
  * @tsplus getter fncts.HashMap witherWithIndex
  */
-export const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (wa) => (G) => (f) =>
-  G.map(wa.traverseWithIndex(G)(f), compact);
+export function _witherWithIndex<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B>(
+  f: (i: K, a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, Maybe<B>>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, HashMap<K, B>> {
+  return (G) => (f) => self.traverseWithIndex(G)(f).pipe(G.map(compact));
+}
 
 /**
  * @tsplus getter fncts.HashMap wither
  */
-export const wither: P.Witherable<HashMapF>["wither"] = (wa) => (G) => (f) => wa.witherWithIndex(G)((_, a) => f(a));
+export function _wither<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B>(
+  f: (a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, Maybe<B>>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, HashMap<K, B>> {
+  return (G) => (f) => self.witherWithIndex(G)((_, a) => f(a));
+}
+
+export const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"] = (G) => (f) => (wa) =>
+  wa.witherWithIndex(G)(f);
+
+export const wither: P.Witherable<HashMapF>["wither"] = (G) => (f) => (wa) => wa.witherWithIndex(G)((_, a) => f(a));
 
 /**
  * @tsplus getter fncts.HashMap wiltWithIndex
  */
-export const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (wa) => (G) => (f) =>
-  G.map(wa.traverseWithIndex(G)(f), separate);
+export function _wiltWithIndex<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B, B2>(
+  f: (i: K, a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, Either<B, B2>>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, readonly [HashMap<K, B>, HashMap<K, B2>]> {
+  return (G) => (f) => self.traverseWithIndex(G)(f).pipe(G.map(separate));
+}
 
 /**
  * @tsplus getter fncts.HashMap wilt
  */
-export const wilt: P.Witherable<HashMapF>["wilt"] = (wa) => (G) => (f) => wa.wiltWithIndex(G)((_, a) => f(a));
+export function _wilt<K, A>(
+  self: HashMap<K, A>,
+): <G extends HKT, GC = HKT.None>(
+  G: P.Applicative<G, GC>,
+) => <K1, Q, W, X, I, S, R, E, B, B2>(
+  f: (a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, Either<B, B2>>,
+) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, readonly [HashMap<K, B>, HashMap<K, B2>]> {
+  return (G) => (f) => self.wiltWithIndex(G)((_, a) => f(a));
+}
+
+export const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"] = (G) => (f) => (wa) =>
+  wa.wiltWithIndex(G)(f);
+
+export const wilt: P.Witherable<HashMapF>["wilt"] = (G) => (f) => (wa) => wa.wiltWithIndex(G)((_, a) => f(a));
 
 /**
- * @tsplus fluent fncts.HashMap unionWith
+ * @tsplus pipeable fncts.HashMap unionWith
  */
-export function unionWith_<K, A>(
-  self: HashMap<K, A>,
-  that: Iterable<readonly [K, A]>,
-  f: (x: A, y: A) => A,
-): HashMap<K, A> {
-  return self.mutate((m) => {
-    for (const [k, a] of that) {
-      m.modify(k, (v) =>
-        v.match(
-          () => Just(a),
-          (a0) => Just(f(a0, a)),
-        ),
-      );
-    }
-  });
+export function unionWith<K, A>(that: Iterable<readonly [K, A]>, f: (x: A, y: A) => A) {
+  return (self: HashMap<K, A>): HashMap<K, A> => {
+    return self.mutate((m) => {
+      for (const [k, a] of that) {
+        m.modify(k, (v) =>
+          v.match(
+            () => Just(a),
+            (a0) => Just(f(a0, a)),
+          ),
+        );
+      }
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap union
+ * @tsplus pipeable fncts.HashMap union
  */
-export function union_<K, A>(self: HashMap<K, A>, that: Iterable<readonly [K, A]>): HashMap<K, A> {
-  return self.mutate((m) => {
-    for (const [k, a] of that) {
-      m.set(k, a);
-    }
-  });
+export function union<K, A>(that: Iterable<readonly [K, A]>) {
+  return (self: HashMap<K, A>): HashMap<K, A> => {
+    return self.mutate((m) => {
+      for (const [k, a] of that) {
+        m.set(k, a);
+      }
+    });
+  };
 }
 
 /**
- * @tsplus fluent fncts.HashMap pop
+ * @tsplus pipeable fncts.HashMap pop
  */
-export function pop_<K, A>(map: HashMap<K, A>, k: K): Maybe<readonly [A, HashMap<K, A>]> {
-  return map.get(k).map((a) => [a, map.remove(k)]);
+export function pop<K>(k: K) {
+  return <A>(map: HashMap<K, A>): Maybe<readonly [A, HashMap<K, A>]> => {
+    return map.get(k).map((a) => [a, map.remove(k)]);
+  };
 }
 
 /*