@fncts/base 0.0.20 → 0.0.22

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";
 
 /**
@@ -17,8 +18,8 @@ import * as P from "@fncts/base/typeclass";
  *
  * @tsplus getter fncts.HashMap isEmpty
  */
-export function isEmpty<K, V>(map: HashMap<K, V>): boolean {
-  return map && isEmptyNode(map.root);
+export function isEmpty<K, V>(self: HashMap<K, V>): boolean {
+  return self && isEmptyNode(self.root);
 }
 
 /**
@@ -33,8 +34,8 @@ export function makeWith<K, V>(config: P.HashEq<K>): HashMap<K, V> {
 /**
  * @tsplus static fncts.HashMapOps __call
  */
-export function make<K, V>(...items: readonly (readonly [K, V])[]): HashMap<K, V> {
-  return makeDefault<K, V>().mutate((map) => {
+export function make<K, V>(...items: ReadonlyArray<readonly [K, V]>): HashMap<K, V> {
+  return HashMap.empty<any, any>().mutate((map) => {
     for (const [key, value] of items) {
       map.set(key, value);
     }
@@ -44,64 +45,75 @@ export function make<K, V>(...items: readonly (readonly [K, V])[]): HashMap<K, V
 /**
  * Make a new map that has randomly cached hash and structural equality
  *
- * @tsplus static fncts.HashMapOps makeDefault
+ * @tsplus static fncts.HashMapOps empty
  */
-export function makeDefault<K, V>(): HashMap<K, V> {
-  return makeWith<K, V>(P.HashEq.StructuralStrict);
+export function empty<K, V>(): HashMap<K, V> {
+  return HashMap.makeWith<K, V>(P.HashEq.StructuralStrict);
 }
 
 /**
  * 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 <K_, Q, W, X, I, S, R, E>(self: HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>): HashMap<K, A> => {
+    return pipe(
+      self,
+      F.foldLeft(makeWith(config), (b, [k, a]) => {
+        const oa: Maybe<A> = b.get(k);
+        if (oa.isJust()) {
+          return b.set(k, S.combine(a)(oa.value));
+        } 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>(self: HashMap<K, V>): Maybe<V> => {
+    return tryGetHash(self, 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>(self: HashMap<K, V>): Maybe<V> => {
+    return tryGetHash(self, key, self.config.hash(key));
+  };
 }
 
 /**
  * Does an entry exist for `key` in `map`? Uses custom `hash`.
  *
- * @tsplus fluent fncts.HashMap hashHash
+ * @tsplus pipeable fncts.HashMap hasHash
  */
-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>(self: HashMap<K, V>): boolean => {
+    return tryGetHash(self, 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>(self: HashMap<K, V>): boolean => {
+    return tryGetHash(self, key, self.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 (self: HashMap<K, V>): HashMap<K, V> => {
+    const size    = { value: self.size };
+    const newRoot = self.root.modify(self.editable ? self.edit : NaN, self.config.equals, 0, f, hash, key, size);
+    return setTree(self, 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 (self: HashMap<K, V>): HashMap<K, V> => {
+    return self.modifyHash(key, self.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 (self: HashMap<K, V>): HashMap<K, V> => {
+    return self.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>(self: HashMap<K, V>): HashMap<K, V> => {
+    return self.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>(self: HashMap<K, V>): HashMap<K, V> => {
+    return self.mutate((m) => {
+      for (const k of keys) {
+        m.remove(k);
+      }
+    });
+  };
 }
 
 /**
@@ -172,8 +194,8 @@ export function removeMany_<K, V>(map: HashMap<K, V>, keys: Iterable<K>): HashMa
  *
  * @tsplus getter fncts.HashMap beginMutation
  */
-export function beginMutation<K, V>(map: HashMap<K, V>): HashMap<K, V> {
-  return new HashMap(true, map.edit + 1, map.config, map.root, map.size);
+export function beginMutation<K, V>(self: HashMap<K, V>): HashMap<K, V> {
+  return new HashMap(true, self.edit + 1, self.config, self.root, self.size);
 }
 
 /**
@@ -181,20 +203,22 @@ export function beginMutation<K, V>(map: HashMap<K, V>): HashMap<K, V> {
  *
  * @tsplus getter fncts.HashMap endMutation
  */
-export function endMutation<K, V>(map: HashMap<K, V>): HashMap<K, V> {
-  map.editable = false;
-  return map;
+export function endMutation<K, V>(self: HashMap<K, V>): HashMap<K, V> {
+  self.editable = false;
+  return self;
 }
 
 /**
  * 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 (self: HashMap<K, V>): HashMap<K, V> => {
+    const transient = self.beginMutation;
+    f(transient);
+    return transient.endMutation;
+  };
 }
 
 /**
@@ -202,8 +226,8 @@ export function mutate_<K, V>(map: HashMap<K, V>, f: (map: HashMap<K, V>) => voi
  *
  * @tsplus getter fncts.HashMap keys
  */
-export function keys<K, V>(map: HashMap<K, V>): IterableIterator<K> {
-  return new HashMapIterator(map, ([k]) => k);
+export function keys<K, V>(self: HashMap<K, V>): IterableIterator<K> {
+  return new HashMapIterator(self, ([k]) => k);
 }
 
 /**
@@ -212,7 +236,7 @@ export function keys<K, V>(map: HashMap<K, V>): IterableIterator<K> {
  * @tsplus getter fncts.HashMap keySet
  */
 export function keySet<K, V>(self: HashMap<K, V>): HashSet<K> {
-  return HashSet.make(self.config).mutate((set) => {
+  return HashSet.emptyWith(self.config).mutate((set) => {
     self.forEachWithIndex((k) => {
       set.add(k);
     });
@@ -222,11 +246,11 @@ export function keySet<K, V>(self: HashMap<K, V>): HashSet<K> {
 /**
  * Get the set of values
  *
- * @tsplus getter fncts.HashMap keySetDefault
+ * @tsplus getter fncts.HashMap toSet
  */
-export function toSetDefault<K, V>(map: HashMap<K, V>): HashSet<V> {
-  return HashSet.makeDefault<V>().mutate((set) => {
-    map.forEach((v) => {
+export function toSet<K, V>(self: HashMap<K, V>): HashSet<V> {
+  return HashSet.empty<V>().mutate((set) => {
+    self.forEach((v) => {
       set.add(v);
     });
   });
@@ -237,9 +261,9 @@ export function toSetDefault<K, V>(map: HashMap<K, V>): HashSet<V> {
  *
  * @tsplus getter fncts.HashMap toList
  */
-export function toList<K, V>(map: HashMap<K, V>): List<readonly [K, V]> {
+export function toList<K, V>(self: HashMap<K, V>): List<readonly [K, V]> {
   const buffer = new ListBuffer<readonly [K, V]>();
-  map.forEachWithIndex((k, v) => {
+  self.forEachWithIndex((k, v) => {
     buffer.append([k, v]);
   });
   return buffer.toList;
@@ -250,10 +274,10 @@ export function toList<K, V>(map: HashMap<K, V>): List<readonly [K, V]> {
  *
  * @tsplus getter fncts.HashMap toArray
  */
-export function toArray<K, V>(map: HashMap<K, V>): Array<readonly [K, V]> {
-  const buffer: Array<readonly [K, V]> = Array(map.size);
+export function toArray<K, V>(self: HashMap<K, V>): Array<readonly [K, V]> {
+  const buffer: Array<readonly [K, V]> = Array(self.size);
   let i = 0;
-  map.forEachWithIndex((k, v) => {
+  self.forEachWithIndex((k, v) => {
     buffer[i] = [k, v];
     i++;
   });
@@ -265,77 +289,91 @@ export function toArray<K, V>(map: HashMap<K, V>): Array<readonly [K, V]> {
  *
  * @tsplus getter fncts.HashMap values
  */
-export function values<K, V>(map: HashMap<K, V>): IterableIterator<V> {
-  return new HashMapIterator(map, ([, v]) => v);
+export function values<K, V>(self: HashMap<K, V>): IterableIterator<V> {
+  return new HashMapIterator(self, ([, v]) => 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 (self: HashMap<K, V>): HashMap<K, V> => {
+    return self.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 (self: HashMap<K, V>): void => {
+    self.foldLeftWithIndex(undefined as void, (key, _, value) => f(key, value, self));
+  };
 }
 
 /**
  * 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 (self: HashMap<K, V>): void => {
+    return self.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 (self: HashMap<K, V>): HashMap<K, A> => {
+    return self.foldLeftWithIndex(makeWith<K, A>(self.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>(self: HashMap<K, V>): HashMap<K, A> => {
+    return self.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 (self: HashMap<K, V>): HashMap<K, A> => {
+    return self.foldLeftWithIndex(makeWith<K, A>(self.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 (self: HashMap<K, V>): HashMap<K, A> => {
+    return self.flatMapWithIndex((_, a) => f(a));
+  };
 }
 
 /**
@@ -343,8 +381,8 @@ export function flatMap_<K, V, A>(ma: HashMap<K, V>, f: (v: V) => HashMap<K, A>)
  *
  * @tsplus getter fncts.HashMap compact
  */
-export function compact<K, A>(map: HashMap<K, Maybe<A>>): HashMap<K, A> {
-  return map.filterMap(Function.identity);
+export function compact<K, A>(self: HashMap<K, Maybe<A>>): HashMap<K, A> {
+  return self.filterMap(Function.identity);
 }
 
 /**
@@ -352,268 +390,338 @@ export function compact<K, A>(map: HashMap<K, Maybe<A>>): HashMap<K, A> {
  *
  * @tsplus getter fncts.HashMap separate
  */
-export function separate<K, A, B>(map: HashMap<K, Either<A, B>>): readonly [HashMap<K, A>, HashMap<K, B>] {
-  return map.partitionMap(Function.identity);
+export function separate<K, A, B>(self: HashMap<K, Either<A, B>>): readonly [HashMap<K, A>, HashMap<K, B>] {
+  return self.partitionMap(Function.identity);
 }
 
 /**
  * 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 (self: HashMap<K, A>): HashMap<K, B> => {
+    return makeWith<K, B>(self.config).mutate((m) => {
+      for (const [k, a] of self) {
+        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>(self: HashMap<K, A>): HashMap<K, B> => {
+    return self.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);
+): (self: HashMap<K, A>) => HashMap<K, B>;
+export function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>): (self: HashMap<K, A>) => HashMap<K, A>;
+export function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>) {
+  return (self: HashMap<K, A>): HashMap<K, A> => {
+    return makeWith<K, A>(self.config).mutate((m) => {
+      for (const [k, a] of self) {
+        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>(self: HashMap<K, A>) => HashMap<K, B>;
+export function filter<A>(predicate: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>;
+export function filter<A>(predicate: Predicate<A>) {
+  return <K>(self: HashMap<K, A>): HashMap<K, A> => {
+    return self.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 (self: HashMap<K, V>): readonly [HashMap<K, A>, HashMap<K, B>] => {
+    const left  = makeWith<K, A>(self.config).beginMutation;
+    const right = makeWith<K, B>(self.config).beginMutation;
+    self.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>(self: HashMap<K, V>): readonly [HashMap<K, A>, HashMap<K, B>] => {
+    return self.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>,
+): (self: 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];
+): (self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export function partitionWithIndex<K, V>(predicate: PredicateWithIndex<K, V>) {
+  return (self: HashMap<K, V>): readonly [HashMap<K, V>, HashMap<K, V>] => {
+    const left  = makeWith<K, V>(self.config).beginMutation;
+    const right = makeWith<K, V>(self.config).beginMutation;
+    self.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>(self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
+export function partition<V>(
+  predicate: Predicate<V>,
+): <K>(self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export function partition<V>(predicate: Predicate<V>) {
+  return <K>(self: HashMap<K, V>): readonly [HashMap<K, V>, HashMap<K, V>] => {
+    return self.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 (self: HashMap<K, V>): Z => {
+    const root = self.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>(self: HashMap<K, V>): Z => {
+    return self.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));
-
-/**
- * @tsplus fluent fncts.HashMap unionWith
- */
-export function unionWith_<K, A>(
+export function _wilt<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)),
-        ),
-      );
-    }
-  });
+): <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 union
+ * @tsplus pipeable fncts.HashMap unionWith
  */
-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 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 pop
+ * @tsplus pipeable fncts.HashMap union
  */
-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 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);
+      }
+    });
+  };
 }
 
-/*
- * -------------------------------------------------------------------------------------------------
- * internal
- * -------------------------------------------------------------------------------------------------
+/**
+ * @tsplus pipeable fncts.HashMap pop
  */
+export function pop<K>(k: K) {
+  return <A>(self: HashMap<K, A>): Maybe<readonly [A, HashMap<K, A>]> => {
+    return self.get(k).map((a) => [a, self.remove(k)]);
+  };
+}
 
 /**
  * Set the root of the map
@@ -639,14 +747,14 @@ function tryGetHash<K, V>(map: HashMap<K, V>, key: K, hash: number): Maybe<V> {
   while (true) {
     switch (node._tag) {
       case "LeafNode": {
-        return keyEq(node.key, key) ? node.value : Nothing();
+        return keyEq(key)(node.key) ? node.value : 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;
+            if ("key" in child && keyEq(key)(child.key)) return child.value;
           }
         }
         return Nothing();