@fncts/base 0.0.21 → 0.0.23

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>]>;

package/collection/immutable/HashMap/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 { Maybe } from "@fncts/base/data/Maybe/definition";
 import type { Node } from "@fncts/base/collection/immutable/HashMap/internal";
 import type { HashEq } from "@fncts/base/typeclass";
@@ -12,23 +12,36 @@ export interface HashMapF extends HKT {
     };
     index: this["K"];
 }
+export declare const HashMapVariance: unique symbol;
+export type HashMapVariance = typeof HashMapVariance;
+export declare const HashMapTypeId: unique symbol;
+export type HashMapTypeId = typeof HashMapTypeId;
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
  */
-export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
+export declare class HashMap<in out K, in out V> implements Iterable<readonly [K, V]>, Hashable, Equatable {
     editable: boolean;
     edit: number;
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly _K: () => K;
-    readonly _A: () => V;
+    readonly [HashMapTypeId]: HashMapTypeId;
+    [HashMapVariance]: {
+        readonly _K: (_: K) => K;
+        readonly _A: (_: V) => V;
+    };
     constructor(editable: boolean, edit: number, config: HashEq<K>, root: Node<K, V>, size: number);
     [Symbol.iterator](): Iterator<readonly [K, V]>;
     get [Symbol.hash](): number;
     [Symbol.equals](other: unknown): boolean;
 }
+/**
+ * @tsplus static fncts.HashMapOps is
+ * @tsplus location "@fncts/base/collection/immutable/HashMap/definition"
+ */
+export declare function isHashMap<K, V>(u: Iterable<readonly [K, V]>): u is HashMap<K, V>;
+export declare function isHashMap(u: unknown): u is HashMap<unknown, unknown>;
 export declare class HashMapIterator<K, V, T> implements IterableIterator<T> {
     readonly map: HashMap<K, V>;
     readonly f: (node: readonly [K, V]) => T;

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

@@ -4,49 +4,50 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import * as P from "@fncts/base/typeclass";
+import { HashEq } from "@fncts/base/typeclass";
 /**
  * @tsplus pipeable fncts.HashSet add
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function add<A>(value: A): (set: HashSet<A>) => HashSet<A>;
+export declare function add<A>(value: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Mark `set` as mutable.
  * @tsplus getter fncts.HashSet beginMutation
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function beginMutation<K>(set: HashSet<K>): HashSet<K>;
+export declare function beginMutation<K>(self: HashSet<K>): HashSet<K>;
 /**
  * Mark `set` as immutable.
  * @tsplus getter fncts.HashSet endMutation
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function endMutation<K>(set: HashSet<K>): HashSet<K>;
+export declare function endMutation<K>(self: HashSet<K>): HashSet<K>;
 /**
  * Appy f to each element
  * @tsplus pipeable fncts.HashSet forEach
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (map: HashSet<V>) => void;
+export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (self: HashSet<V>) => void;
 /**
  * @tsplus pipeable fncts.HashSet has
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function has<A>(value: A): (set: HashSet<A>) => boolean;
+export declare function has<A>(value: A): (self: HashSet<A>) => boolean;
 /**
- * @tsplus static fncts.HashSetOps make
+ * @tsplus static fncts.HashSetOps emptyWith
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function make<A>(config: P.Hash<A> & P.Eq<A>): HashSet<A>;
+export declare function emptyWith<A>(config: HashEq<A>): HashSet<A>;
 /**
- * @tsplus static fncts.HashSetOps makeDefault
+ * @tsplus static fncts.HashSetOps empty
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function makeDefault<A>(): HashSet<A>;
+export declare function empty<A>(): HashSet<A>;
 /**
- * @tsplus static fncts.HashSetOps fromDefault
+ * @tsplus static fncts.HashSetOps make
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function fromDefault<A>(...values: ReadonlyArray<A>): HashSet<A>;
+export declare function make<A>(...values: ReadonlyArray<A>): HashSet<A>;
 /**
  * Mutate `set` within the context of `f`.
  * @tsplus pipeable fncts.HashSet mutate
@@ -57,38 +58,38 @@ export declare function mutate<A>(transient: (set: HashSet<A>) => void): (self:
  * @tsplus pipeable fncts.HashSet remove
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function remove<A>(value: A): (set: HashSet<A>) => HashSet<A>;
+export declare function remove<A>(value: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Calculate the number of keys pairs in a set
  * @tsplus getter fncts.HashSet size
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function size<A>(set: HashSet<A>): number;
+export declare function size<A>(self: HashSet<A>): number;
 /**
  * If element is present remove it, if not add it
  * @tsplus pipeable fncts.HashSet toggle
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toggle<A>(a: A): (set: HashSet<A>) => HashSet<A>;
+export declare function toggle<A>(a: A): (self: HashSet<A>) => HashSet<A>;
 /**
  * Projects a Set through a function
  */
-export declare function map<B>(C: P.HashEq<B>): <A>(f: (x: A) => B) => (fa: HashSet<A>) => HashSet<B>;
+export declare function mapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => B) => (self: HashSet<A>) => HashSet<B>;
 /**
  * Projects a Set through a function
  * @tsplus pipeable fncts.HashSet map
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mapDefault<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
 /**
  * Map + Flatten
  */
-export declare function flatMap<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
+export declare function flatMapWith<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
 /**
  * @tsplus pipeable fncts.HashSet flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function flatMapDefault<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
+export declare function flatMap<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Creates an equal for a set
  * @tsplus static fncts.HashSetOps getEq
@@ -102,7 +103,12 @@ export declare function getEq<A>(): P.Eq<HashSet<A>>;
  */
 export declare function filter<A, B extends A>(refinement: Refinement<A, B>): (set: HashSet<A>) => HashSet<B>;
 export declare function filter<A>(predicate: Predicate<A>): (set: HashSet<A>) => HashSet<A>;
-export declare function filterMap<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B>;
+export declare function filterMapWith<B>(B: P.HashEq<B>): <A>(f: (a: A) => Maybe<B>) => (fa: HashSet<A>) => HashSet<B>;
+/**
+ * @tsplus pipeable fncts.HashSet filterMap
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Partition set values using predicate
  * @tsplus pipeable fncts.HashSet partition
@@ -113,13 +119,18 @@ export declare function partition<A>(p: Predicate<A>): (self: HashSet<A>) => rea
 /**
  * Partition set values using predicate
  */
-export declare function partitionMap<B, C>(B: P.HashEq<B>, C: P.HashEq<C>): <A>(f: (a: A) => Either<B, C>) => (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>];
+export declare function partitionMapWith<B, C>(B: P.HashEq<B>, C: P.HashEq<C>): <A>(f: (a: A) => Either<B, C>) => (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>];
+/**
+ * @tsplus pipeable fncts.HashSet partitionMap
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
+ */
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: HashSet<A>) => readonly [HashSet<B>, HashSet<C>];
 /**
  * Reduce a state over the set elements
  * @tsplus pipeable fncts.HashSet foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (fa: HashSet<A>) => B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (self: HashSet<A>) => B;
 /**
  * @tsplus pipeable fncts.HashSet join
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
@@ -130,7 +141,7 @@ export declare function join(separator: string): (self: HashSet<string>) => stri
  * @tsplus pipeable fncts.HashSet difference
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function difference<A>(y: Iterable<A>): (x: HashSet<A>) => HashSet<A>;
+export declare function difference<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
  * true if all elements match predicate
  * @tsplus pipeable fncts.HashSet every
@@ -152,13 +163,13 @@ export declare function intersection<A>(that: Iterable<A>): (self: HashSet<A>) =
  * @tsplus pipeable fncts.HashSet isSubset
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function isSubset<A>(y: HashSet<A>): (x: HashSet<A>) => boolean;
+export declare function isSubset<A>(that: HashSet<A>): (self: HashSet<A>) => boolean;
 /**
  * true if one or more elements match predicate
- * @tsplus pipeable fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet some
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function exists<A>(predicate: Predicate<A>): (set: HashSet<A>) => boolean;
+export declare function some<A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean;
 /**
  * Form the union of two sets,
  *
@@ -166,9 +177,9 @@ export declare function exists<A>(predicate: Predicate<A>): (set: HashSet<A>) =>
  * @tsplus pipeable fncts.HashSet union
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function union<A>(r: Iterable<A>): (l: HashSet<A>) => HashSet<A>;
+export declare function union<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
- * @tsplus static fncts.HashSet toArray
+ * @tsplus pipeable fncts.HashSet toArray
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toArray<A>(set: HashSet<A>, O: P.Ord<A>): ReadonlyArray<A>;
+export declare function toArray<A>(O: P.Ord<A>): (self: HashSet<A>) => ReadonlyArray<A>;

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

@@ -1,10 +1,14 @@
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Hashable } from "@fncts/base/data/Hashable";
 import * as P from "@fncts/base/typeclass";
+export declare const HashSetVariance: unique symbol;
+export type HashSetVariance = typeof HashSetVariance;
+export declare const HashSetTypeId: unique symbol;
+export type HashSetTypeId = typeof HashSetTypeId;
 /**
  * @tsplus type fncts.HashSet
  * @tsplus companion fncts.HashSetOps
  */
-export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable {
+export declare class HashSet<in out A> implements Iterable<A>, P.Hashable, P.Equatable {
     /**
      * @internal
      */
@@ -25,6 +29,10 @@ export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable
      * @internal
      */
     _size: number;
+    readonly [HashSetTypeId]: HashSetTypeId;
+    [HashSetVariance]: {
+        readonly _A: (_: A) => A;
+    };
     constructor(
     /**
      * @internal
@@ -51,6 +59,12 @@ export declare class HashSet<A> implements Iterable<A>, P.Hashable, P.Equatable
     get [Symbol.hash](): number;
     [Symbol.equals](other: unknown): boolean;
 }
+/**
+ * @tsplus static fncts.HashSetOps is
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/definition"
+ */
+export declare function isHashSet<A>(u: Iterable<A>): u is HashSet<A>;
+export declare function isHashSet(u: unknown): u is HashSet<unknown>;
 interface SizeRef {
     value: number;
 }
@@ -58,7 +72,7 @@ export declare function canEditNode<A>(edit: number, node: Node<A>): boolean;
 export type Node<A> = EmptyNode<A> | LeafNode<A> | CollisionNode<A> | IndexedNode<A> | ArrayNode<A>;
 export declare class EmptyNode<A> {
     readonly _tag = "EmptyNode";
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): this | LeafNode<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): this | LeafNode<A>;
 }
 export declare const _EmptyNode: EmptyNode<never>;
 export declare function isEmptyNode<A>(n: Node<A>): n is EmptyNode<A>;
@@ -68,7 +82,7 @@ export declare class LeafNode<A> {
     value: A;
     readonly _tag = "LeafNode";
     constructor(edit: number, hash: number, value: A);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare class CollisionNode<A> {
     edit: number;
@@ -76,7 +90,7 @@ export declare class CollisionNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "CollisionNode";
     constructor(edit: number, hash: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare function isLeaf<A>(node: Node<A>): node is EmptyNode<A> | LeafNode<A> | CollisionNode<A>;
 export declare class IndexedNode<A> {
@@ -85,7 +99,7 @@ export declare class IndexedNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "IndexNode";
     constructor(edit: number, mask: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export declare class ArrayNode<A> {
     edit: number;
@@ -93,6 +107,6 @@ export declare class ArrayNode<A> {
     children: Array<Node<A>>;
     readonly _tag = "ArrayNode";
     constructor(edit: number, size: number, children: Array<Node<A>>);
-    modify(remove: boolean, edit: number, eq: (x: A, y: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
+    modify(remove: boolean, edit: number, eq: (y: A) => (x: A) => boolean, shift: number, hash: number, value: A, size: SizeRef): Node<A>;
 }
 export {};