@fncts/base 0.0.21 → 0.0.22

package/_src/typeclass/Closure.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Closure
  */
 export interface Closure<A> {
-  readonly combine: (x: A, y: A) => A;
+  readonly combine: (y: A) => (x: A) => A;
 }
 
 /**
@@ -15,6 +15,6 @@ export const Closure: ClosureOps = {};
 /**
  * @tsplus static fncts.ClosureOps __call
  */
-export function mkClosure<A>(F: Closure<A>): Closure<A> {
+export function makeClosure<A>(F: Closure<A>): Closure<A> {
   return F;
 }

package/_src/typeclass/Foldable.ts

@@ -30,5 +30,5 @@ export function foldMap<F extends HKT, FC = HKT.None>(
   f: (a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
 ) => <K, Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
-  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(b, f(a)));
+  return (f, M) => F.foldLeft(M.nat, (b, a) => M.combine(f(a))(b));
 }

package/_src/typeclass/FoldableWithIndex.ts

@@ -31,5 +31,5 @@ export function foldMapWithIndex<F extends HKT, FC = HKT.None>(
   f: (k: HKT.IndexFor<F, K>, a: A) => M,
   /** @tsplus auto */ M: Monoid<M>,
 ) => <Q, W, X, I, S, R, E>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, E, A>) => M {
-  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(b, f(i, a)));
+  return (f, M) => F.foldLeftWithIndex(M.nat, (i, b, a) => M.combine(f(i, a))(b));
 }

package/_src/typeclass/Monoid.ts

@@ -37,11 +37,11 @@ export function mkMonoid<A>(F: MonoidMin<A>): Monoid<A> {
 export function deriveLazy<A>(fn: (_: Monoid<A>) => Monoid<A>): Monoid<A> {
   let cached: Monoid<A> | undefined;
   const M: Monoid<A> = Monoid({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(M);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
     get nat() {
       if (!cached) {

package/_src/typeclass/Semialign.ts

@@ -225,7 +225,7 @@ export function alignCombine<F extends HKT, FC = HKT.None>(
   HKT.Mix<F, "E", [E, E1]>,
   A
 > {
-  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, S.combine));
+  return (that, S) => F.alignWith(that, (th) => th.match(identity, identity, (a, b) => S.combine(b)(a)));
 }
 
 export interface padZip<F extends HKT, FC = HKT.None> {

package/_src/typeclass/Semigroup/api.ts

@@ -1,6 +1,5 @@
-import type { Ord } from "@fncts/base/typeclass/Ord";
-
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+
 /**
  * @tsplus static fncts.SemigroupOps min
  */
@@ -9,6 +8,7 @@ export function min<A>(O: Ord<A>): Semigroup<A> {
     combine: O.min,
   });
 }
+
 /**
  * @tsplus static fncts.SemigroupOps max
  */

package/_src/typeclass/Semigroup/definition.ts

@@ -1,16 +1,20 @@
 import type { Closure } from "@fncts/base/typeclass/Closure";
 
-import { mkClosure } from "@fncts/base/typeclass/Closure";
+import { makeClosure } from "@fncts/base/typeclass/Closure";
+
 /**
  * @tsplus type fncts.Semigroup
  */
 export interface Semigroup<A> extends Closure<A> {}
+
 /**
  * @tsplus type fncts.SemigroupOps
  */
 export interface SemigroupOps {}
+
 export const Semigroup: SemigroupOps = {};
+
 /**
  * @tsplus static fncts.SemigroupOps __call
  */
-export const mkSemigroup = mkClosure;
+export const makeSemigroup = makeClosure;

package/_src/typeclass/Semigroup/derivations.ts

@@ -2,21 +2,23 @@ import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 
 import { Semigroup } from "@fncts/base/typeclass/Semigroup/definition";
+
 /**
  * @tsplus derive fncts.Semigroup lazy
  */
 export function deriveLazy<A>(fn: (_: Semigroup<A>) => Semigroup<A>): Semigroup<A> {
   let cached: Semigroup<A> | undefined;
   const eq: Semigroup<A> = Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       if (!cached) {
         cached = fn(eq);
       }
-      return cached.combine(x, y);
+      return cached.combine(y)(x);
     },
   });
   return eq;
 }
+
 /**
  * @tsplus derive fncts.Semigroup<_> 20
  * @tsplus static fncts.SemigroupOps deriveStruct
@@ -40,10 +42,10 @@ export function deriveStruct<A extends Record<string, any>>(
     : never
 ): Semigroup<A> {
   return Semigroup({
-    combine: (x, y) => {
+    combine: (y) => (x) => {
       const out: Record<string, unknown> = {};
       for (const field in requiredFields) {
-        out[field] = (requiredFields[field]! as Semigroup<any>).combine(x[field], y[field]);
+        out[field] = (requiredFields[field]! as Semigroup<any>).combine(y[field])(x[field]);
       }
       for (const field in optionalFields) {
         const xf = x[field];
@@ -53,7 +55,7 @@ export function deriveStruct<A extends Record<string, any>>(
         } else if (!(field in y)) {
           out[field] = xf;
         } else {
-          out[field] = optionalFields[field].combine(xf, yf);
+          out[field] = optionalFields[field].combine(yf)(xf);
         }
       }
       return out as A;

package/_src/typeclass.ts

@@ -8,8 +8,6 @@ export * from "./typeclass/Apply.js";
 export * from "./typeclass/builtin.js";
 export * from "./typeclass/Chain.js";
 export * from "./typeclass/Closure.js";
-export * from "./typeclass/Eq.js";
-export * from "./typeclass/Equatable.js";
 export * from "./typeclass/Fail.js";
 export * from "./typeclass/Filterable.js";
 export * from "./typeclass/FilterableWithIndex.js";
@@ -17,17 +15,11 @@ export * from "./typeclass/Foldable.js";
 export * from "./typeclass/FoldableWithIndex.js";
 export * from "./typeclass/Functor.js";
 export * from "./typeclass/FunctorWithIndex.js";
-export * from "./typeclass/Guard.js";
 export * from "./typeclass/Has.js";
-export * from "./typeclass/Hash.js";
-export * from "./typeclass/Hashable.js";
-export * from "./typeclass/HashEq.js";
 export * from "./typeclass/Monad.js";
 export * from "./typeclass/MonadExcept.js";
 export * from "./typeclass/Monoid.js";
 export * from "./typeclass/Nil.js";
-export * from "./typeclass/Ord.js";
-export * from "./typeclass/Ordering.js";
 export * from "./typeclass/Pointed.js";
 export * from "./typeclass/Semialign.js";
 export * from "./typeclass/Semigroup.js";
@@ -37,3 +29,12 @@ export * from "./typeclass/TraversableWithIndex.js";
 export * from "./typeclass/Witherable.js";
 export * from "./typeclass/WitherableWithIndex.js";
 // codegen:end
+
+export { Eq } from "./data/Eq.js";
+export { Equatable } from "./data/Equatable.js";
+export { Guard } from "./data/Guard.js";
+export { Hash } from "./data/Hash.js";
+export { Hashable } from "./data/Hashable.js";
+export { HashEq } from "./data/HashEq.js";
+export { Ord } from "./data/Ord.js";
+export { Ordering } from "./data/Ordering.js";

package/collection/Iterable/api.d.ts

@@ -16,10 +16,10 @@ export declare function ap<A>(fa: Iterable<A>): <B>(self: Iterable<(a: A) => B>)
  */
 export declare function append<B>(b: B): <A>(self: Iterable<A>) => Iterable<B | A>;
 /**
- * @tsplus getter fncts.Iterable asIterable
+ * @tsplus getter fncts.Iterable toIterable
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function asIterable<A>(self: Iterable<A>): Iterable<A>;
+export declare function toIterable<A>(self: Iterable<A>): Iterable<A>;
 /**
  * @tsplus pipeable fncts.Iterable flatMap
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -39,7 +39,7 @@ export declare function corresponds<A, B>(right: Iterable<B>, f: (a: A, b: B) =>
  * @tsplus pipeable fncts.Iterable crossWith
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function crossWith<A, B, C>(fb: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
+export declare function crossWith<A, B, C>(that: Iterable<B>, f: (a: A, b: B) => C): (self: Iterable<A>) => Iterable<C>;
 /**
  * @tsplus pipeable fncts.Iterable every
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -78,8 +78,8 @@ export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (s
  * @tsplus pipeable fncts.Iterable find
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function find<A, B extends A>(refinement: Refinement<A, B>): (ia: Iterable<A>) => Maybe<B>;
-export declare function find<A>(predicate: Predicate<A>): (ia: Iterable<A>) => Maybe<A>;
+export declare function find<A, B extends A>(refinement: Refinement<A, B>): (self: Iterable<A>) => Maybe<B>;
+export declare function find<A>(predicate: Predicate<A>): (self: Iterable<A>) => Maybe<A>;
 /**
  * @tsplus pipeable fncts.Iterable findIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -89,7 +89,7 @@ export declare function findIndex<A>(p: Predicate<A>): (self: Iterable<A>) => nu
  * @tsplus pipeable fncts.Iterable foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (fa: Iterable<A>) => B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: Iterable<A>) => B;
 /**
  * @tsplus pipeable fncts.Iterable foldLeft
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -134,7 +134,7 @@ export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self:
  * @tsplus pipeable fncts.Iterable partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/Iterable/api"
  */
-export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (fa: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (self: Iterable<A>) => readonly [Iterable<B>, Iterable<C>];
 /**
  * @tsplus pipeable fncts.Iterable partition
  * @tsplus location "@fncts/base/collection/Iterable/api"
@@ -147,6 +147,11 @@ export declare function partition<A>(p: Predicate<A>): (self: Iterable<A>) => re
  */
 export declare function partitionWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<B>];
 export declare function partitionWithIndex<A>(p: PredicateWithIndex<number, A>): (self: Iterable<A>) => readonly [Iterable<A>, Iterable<A>];
+/**
+ * @tsplus static fncts.IterableOps replicate
+ * @tsplus location "@fncts/base/collection/Iterable/api"
+ */
+export declare function replicate<A>(n: number, a: A): Iterable<A>;
 /**
  * @tsplus getter fncts.Iterable size
  * @tsplus location "@fncts/base/collection/Iterable/api"

package/collection/compat/Array.d.ts

@@ -1,3 +1,2 @@
 export * from "./Array/api.js";
 export * from "./Array/definition.js";
-export * from "./Array/derivations.js";

package/collection/compat/ArrayLike/api.d.ts

@@ -1,5 +1,5 @@
 /**
- * @tsplus getter fncts.ArrayLike asIterable
+ * @tsplus getter fncts.ArrayLike toIterable
  * @tsplus location "@fncts/base/collection/compat/ArrayLike/api"
  */
-export declare function asIterable<A>(self: ArrayLike<A>): Iterable<A>;
+export declare function toIterable<A>(self: ArrayLike<A>): Iterable<A>;

package/collection/compat.d.ts

@@ -1,2 +1 @@
 export type {} from "./compat/Array.js";
-export type {} from "./compat/Record.js";

package/collection/immutable/Conc/api.d.ts

@@ -82,10 +82,10 @@ export declare function concat<B>(that: Conc<B>): <A>(self: import("@fncts/base/
  */
 export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Conc<A>) => boolean;
 /**
- * @tsplus pipeable fncts.Conc exists
+ * @tsplus pipeable fncts.Conc some
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"
  */
-export declare function exists<A>(predicate: Predicate<A>): (as: Conc<A>) => boolean;
+export declare function some<A>(predicate: Predicate<A>): (as: Conc<A>) => boolean;
 /**
  * @tsplus pipeable fncts.Conc drop
  * @tsplus location "@fncts/base/collection/immutable/Conc/api"

package/collection/immutable/Conc/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import { isByte } from "@fncts/base/util/predicates";
 import { IndexOutOfBoundsError, ArrayIndexOutOfBoundsError } from "@fncts/base/data/exceptions";
 import { unsafeCoerce } from "@fncts/base/data/function/api";

package/collection/immutable/Conc.d.ts

@@ -1,7 +1,6 @@
 export * from "./Conc/api.js";
 export * from "./Conc/constructors.js";
 export * from "./Conc/definition.js";
-export * from "./Conc/derivations.js";
 export * from "./Conc/api/empty.js";
 export * from "./Conc/api/makeBy.js";
 export * from "./Conc/api/replicate.js";

package/collection/immutable/Dictionary.d.ts

@@ -0,0 +1,2 @@
+export * from "./Dictionary/api.js";
+export * from "./Dictionary/definition.js";

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

@@ -14,7 +14,7 @@ import * as P from "@fncts/base/typeclass";
  * @tsplus getter fncts.HashMap isEmpty
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function isEmpty<K, V>(map: HashMap<K, V>): boolean;
+export declare function isEmpty<K, V>(self: HashMap<K, V>): boolean;
 /**
  * Creates a new map
  * @tsplus static fncts.HashMapOps makeWith
@@ -25,43 +25,43 @@ export declare function makeWith<K, V>(config: P.HashEq<K>): HashMap<K, V>;
  * @tsplus static fncts.HashMapOps __call
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function make<K, V>(...items: readonly (readonly [K, V])[]): HashMap<K, V>;
+export declare function make<K, V>(...items: ReadonlyArray<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
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function makeDefault<K, V>(): HashMap<K, V>;
+export declare function empty<K, V>(): HashMap<K, V>;
 /**
  * Makes a new map from a Foldable of key-value pairs
  * @tsplus pipeable fncts.HashMapOps fromFoldable
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>): <K_, Q, W, X, I, S, R, E>(fka: import("@fncts/typelevel/HKT.js").HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>) => HashMap<K, A>;
+export declare function fromFoldable<F extends HKT, C, K, A>(config: P.HashEq<K>, S: P.Semigroup<A>, F: P.Foldable<F, C>): <K_, Q, W, X, I, S, R, E>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, C, K_, Q, W, X, I, S, R, E, readonly [K, A]>) => HashMap<K, A>;
 /**
  * Lookup the value for `key` in `map` using custom hash.
  * @tsplus pipeable fncts.HashMap getHash
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function getHash<K>(key: K, hash: number): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("../../../data/Maybe.js").Maybe<V>;
+export declare function getHash<K>(key: K, hash: number): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("../../../data/Maybe.js").Maybe<V>;
 /**
  * Lookup the value for `key` in `map` using internal hash function.
  * @tsplus pipeable fncts.HashMap get
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function get<K>(key: K): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("../../../data/Maybe.js").Maybe<V>;
+export declare function get<K>(key: K): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("../../../data/Maybe.js").Maybe<V>;
 /**
  * Does an entry exist for `key` in `map`? Uses custom `hash`.
- * @tsplus pipeable fncts.HashMap hashHash
+ * @tsplus pipeable fncts.HashMap hasHash
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function hasHash<K>(key: K, hash: number): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => boolean;
+export declare function hasHash<K>(key: K, hash: number): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => boolean;
 /**
  * Does an entry exist for `key` in `map`? Uses internal hash function.
  * @tsplus pipeable fncts.HashMap has
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function has<K>(key: K): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => boolean;
+export declare function has<K>(key: K): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => boolean;
 /**
  * Alter the value stored for `key` in `map` using function `f` using custom hash.
  *
@@ -73,7 +73,7 @@ export declare function has<K>(key: K): <V>(map: import("@fncts/base/collection/
  * @tsplus pipeable fncts.HashMap modifyHash
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function modifyHash<K, V>(key: K, hash: number, f: UpdateFn<V>): (map: HashMap<K, V>) => HashMap<K, V>;
+export declare function modifyHash<K, V>(key: K, hash: number, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Alter the value stored for `key` in `map` using function `f` using internal hash function.
  *
@@ -85,49 +85,49 @@ export declare function modifyHash<K, V>(key: K, hash: number, f: UpdateFn<V>):
  * @tsplus pipeable fncts.HashMap modify
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function modify<K, V>(key: K, f: UpdateFn<V>): (map: HashMap<K, V>) => HashMap<K, V>;
+export declare function modify<K, V>(key: K, f: UpdateFn<V>): (self: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Store `value` for `key` in `map` using internal hash function.
  * @tsplus pipeable fncts.HashMap set
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function set<K, V>(key: K, value: V): (map: HashMap<K, V>) => HashMap<K, V>;
+export declare function set<K, V>(key: K, value: V): (self: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Remove the entry for `key` in `map` using internal hash.
  * @tsplus pipeable fncts.HashMap remove
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function remove<K>(key: K): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>;
+export declare function remove<K>(key: K): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>;
 /**
  * Remove many keys
  * @tsplus pipeable fncts.HashMap removeMany
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function removeMany<K>(keys: Iterable<K>): <V>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>;
+export declare function removeMany<K>(keys: Iterable<K>): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>;
 /**
  * Mark `map` as mutable.
  * @tsplus getter fncts.HashMap beginMutation
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function beginMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
+export declare function beginMutation<K, V>(self: HashMap<K, V>): HashMap<K, V>;
 /**
  * Mark `map` as immutable.
  * @tsplus getter fncts.HashMap endMutation
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function endMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
+export declare function endMutation<K, V>(self: HashMap<K, V>): HashMap<K, V>;
 /**
  * Mutate `map` within the context of `f`.
  * @tsplus pipeable fncts.HashMap mutate
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function mutate<K, V>(f: (map: HashMap<K, V>) => void): (map: HashMap<K, V>) => HashMap<K, V>;
+export declare function mutate<K, V>(f: (map: HashMap<K, V>) => void): (self: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Get an IterableIterator of the map keys
  * @tsplus getter fncts.HashMap keys
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function keys<K, V>(map: HashMap<K, V>): IterableIterator<K>;
+export declare function keys<K, V>(self: HashMap<K, V>): IterableIterator<K>;
 /**
  * Get the set of keys
  * @tsplus getter fncts.HashMap keySet
@@ -136,142 +136,142 @@ export declare function keys<K, V>(map: HashMap<K, V>): IterableIterator<K>;
 export declare 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
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function toSetDefault<K, V>(map: HashMap<K, V>): HashSet<V>;
+export declare function toSet<K, V>(self: HashMap<K, V>): HashSet<V>;
 /**
  * Get the set of values
  * @tsplus getter fncts.HashMap toList
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function toList<K, V>(map: HashMap<K, V>): List<readonly [K, V]>;
+export declare function toList<K, V>(self: HashMap<K, V>): List<readonly [K, V]>;
 /**
  * Get the set of values
  * @tsplus getter fncts.HashMap toArray
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function toArray<K, V>(map: HashMap<K, V>): Array<readonly [K, V]>;
+export declare function toArray<K, V>(self: HashMap<K, V>): Array<readonly [K, V]>;
 /**
  * Get an IterableIterator of the map values
  * @tsplus getter fncts.HashMap values
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function values<K, V>(map: HashMap<K, V>): IterableIterator<V>;
+export declare function values<K, V>(self: HashMap<K, V>): IterableIterator<V>;
 /**
  * Update a value if exists
  * @tsplus pipeable fncts.HashMap update
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function update<K, V>(key: K, f: (v: V) => V): (map: HashMap<K, V>) => HashMap<K, V>;
+export declare function update<K, V>(key: K, f: (v: V) => V): (self: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Apply f to each element
  * @tsplus pipeable fncts.HashMap forEachWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function forEachWithIndex<K, V>(f: (k: K, v: V, m: HashMap<K, V>) => void): (map: HashMap<K, V>) => void;
+export declare function forEachWithIndex<K, V>(f: (k: K, v: V, m: HashMap<K, V>) => void): (self: HashMap<K, V>) => void;
 /**
  * Apply f to each element
  * @tsplus pipeable fncts.HashMap forEach
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function forEach<K, V>(f: (v: V, m: HashMap<K, V>) => void): (map: HashMap<K, V>) => void;
+export declare function forEach<K, V>(f: (v: V, m: HashMap<K, V>) => void): (self: HashMap<K, V>) => void;
 /**
  * Maps over the map entries
  * @tsplus pipeable fncts.HashMap mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function mapWithIndex<K, V, A>(f: (k: K, v: V) => A): (fa: HashMap<K, V>) => HashMap<K, A>;
+export declare function mapWithIndex<K, V, A>(f: (k: K, v: V) => A): (self: HashMap<K, V>) => HashMap<K, A>;
 /**
  * Maps over the map entries
  * @tsplus pipeable fncts.HashMap map
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function map<V, A>(f: (v: V) => A): <K>(fa: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>;
+export declare function map<V, A>(f: (v: V) => A): <K>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>;
 /**
  * Chain over the map entries, the hash and equal of the 2 maps has to be the same
  * @tsplus pipeable fncts.HashMap flatMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function flatMapWithIndex<K, V, A>(f: (k: K, v: V) => HashMap<K, A>): (ma: HashMap<K, V>) => HashMap<K, A>;
+export declare function flatMapWithIndex<K, V, A>(f: (k: K, v: V) => HashMap<K, A>): (self: HashMap<K, V>) => HashMap<K, A>;
 /**
  * Chain over the map entries, the hash and equal of the 2 maps has to be the same
  * @tsplus pipeable fncts.HashMap flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function flatMap<K, V, A>(f: (v: V) => HashMap<K, A>): (ma: HashMap<K, V>) => HashMap<K, A>;
+export declare function flatMap<K, V, A>(f: (v: V) => HashMap<K, A>): (self: HashMap<K, V>) => HashMap<K, A>;
 /**
  * Removes values that are `Nothing`
  * @tsplus getter fncts.HashMap compact
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function compact<K, A>(map: HashMap<K, Maybe<A>>): HashMap<K, A>;
+export declare function compact<K, A>(self: HashMap<K, Maybe<A>>): HashMap<K, A>;
 /**
  * Removes `Either` values into two separate `HashMaps`
  * @tsplus getter fncts.HashMap separate
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function separate<K, A, B>(map: HashMap<K, Either<A, B>>): readonly [HashMap<K, A>, HashMap<K, B>];
+export declare function separate<K, A, B>(self: HashMap<K, Either<A, B>>): readonly [HashMap<K, A>, HashMap<K, B>];
 /**
  * Filter out None and map
  * @tsplus pipeable fncts.HashMap filterMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterMapWithIndex<K, A, B>(f: (k: K, a: A) => Maybe<B>): (map: HashMap<K, A>) => HashMap<K, B>;
+export declare function filterMapWithIndex<K, A, B>(f: (k: K, a: A) => Maybe<B>): (self: HashMap<K, A>) => HashMap<K, B>;
 /**
  * Filter out None and map
  * @tsplus pipeable fncts.HashMap filterMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <K>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <K>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>) => import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, B>;
 /**
  * Filter out by predicate
  * @tsplus pipeable fncts.HashMap filterWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterWithIndex<K, A, B extends A>(refinement: RefinementWithIndex<K, A, B>): (map: HashMap<K, A>) => HashMap<K, B>;
-export declare function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>): (map: HashMap<K, A>) => HashMap<K, A>;
+export declare function filterWithIndex<K, A, B extends A>(refinement: RefinementWithIndex<K, A, B>): (self: HashMap<K, A>) => HashMap<K, B>;
+export declare function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>): (self: HashMap<K, A>) => HashMap<K, A>;
 /**
  * Filter out by predicate
  * @tsplus pipeable fncts.HashMap filter
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <K>(map: HashMap<K, A>) => HashMap<K, B>;
-export declare function filter<A>(predicate: Predicate<A>): <K>(map: HashMap<K, A>) => HashMap<K, A>;
+export declare function filter<A, B extends A>(refinement: Refinement<A, B>): <K>(self: HashMap<K, A>) => HashMap<K, B>;
+export declare function filter<A>(predicate: Predicate<A>): <K>(self: HashMap<K, A>) => HashMap<K, A>;
 /**
  * @tsplus pipeable fncts.HashMap partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partitionMapWithIndex<K, V, A, B>(f: (i: K, a: V) => Either<A, B>): (map: HashMap<K, V>) => readonly [HashMap<K, A>, HashMap<K, B>];
+export declare function partitionMapWithIndex<K, V, A, B>(f: (i: K, a: V) => Either<A, B>): (self: HashMap<K, V>) => readonly [HashMap<K, A>, HashMap<K, B>];
 /**
  * @tsplus pipeable fncts.HashMap partitionMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partitionMap<V, A, B>(f: (a: V) => Either<A, B>): <K>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => readonly [import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, B>];
+export declare function partitionMap<V, A, B>(f: (a: V) => Either<A, B>): <K>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => readonly [import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, B>];
 /**
  * @tsplus pipeable fncts.HashMap partitionWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partitionWithIndex<K, V, B extends V>(refinement: RefinementWithIndex<K, V, B>): (map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
-export declare function partitionWithIndex<K, V>(predicate: PredicateWithIndex<K, V>): (map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export declare function partitionWithIndex<K, V, B extends V>(refinement: RefinementWithIndex<K, V, B>): (self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
+export declare function partitionWithIndex<K, V>(predicate: PredicateWithIndex<K, V>): (self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
 /**
  * @tsplus pipeable fncts.HashMap partition
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partition<V, B extends V>(refinement: Refinement<V, B>): <K>(map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
-export declare function partition<V>(predicate: Predicate<V>): <K>(map: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
+export declare function partition<V, B extends V>(refinement: Refinement<V, B>): <K>(self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, B>];
+export declare function partition<V>(predicate: Predicate<V>): <K>(self: HashMap<K, V>) => readonly [HashMap<K, V>, HashMap<K, V>];
 /**
  * Reduce a state over the map entries
  * @tsplus pipeable fncts.HashMap foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function foldLeftWithIndex<K, V, Z>(z: Z, f: (k: K, z: Z, v: V) => Z): (map: HashMap<K, V>) => Z;
+export declare function foldLeftWithIndex<K, V, Z>(z: Z, f: (k: K, z: Z, v: V) => Z): (self: HashMap<K, V>) => Z;
 /**
  * Reduce a state over the map entries
  * @tsplus pipeable fncts.HashMap foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function foldLeft<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => Z;
+export declare function foldLeft<V, Z>(z: Z, f: (z: Z, v: V) => Z): <K>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => Z;
 /**
  * @tsplus getter fncts.HashMap traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
@@ -327,4 +327,4 @@ export declare function union<K, A>(that: Iterable<readonly [K, A]>): (self: Has
  * @tsplus pipeable fncts.HashMap pop
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function pop<K>(k: K): <A>(map: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>) => import("../../../data/Maybe.js").Maybe<readonly [A, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>]>;
+export declare function pop<K>(k: K): <A>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>) => import("../../../data/Maybe.js").Maybe<readonly [A, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, A>]>;