@fncts/base 0.0.20 → 0.0.22

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 fluent fncts.HashMapOps fromFoldable
+ * @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 fluent fncts.HashMap getHash
+ * @tsplus pipeable fncts.HashMap getHash
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function getHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): 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 fluent fncts.HashMap get
+ * @tsplus pipeable fncts.HashMap get
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function get_<K, V>(map: HashMap<K, V>, key: K): 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 fluent fncts.HashMap hashHash
+ * @tsplus pipeable fncts.HashMap hasHash
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function hasHash_<K, V>(map: HashMap<K, V>, key: K, hash: number): 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 fluent fncts.HashMap has
+ * @tsplus pipeable fncts.HashMap has
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function has_<K, V>(map: HashMap<K, V>, key: K): 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.
  *
@@ -70,10 +70,10 @@ export declare 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
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: number, f: UpdateFn<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.
  *
@@ -82,52 +82,52 @@ export declare function modifyHash_<K, V>(map: HashMap<K, V>, key: K, hash: numb
  *
  * `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
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function modify_<K, V>(map: HashMap<K, V>, key: K, f: UpdateFn<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 fluent fncts.HashMap set
+ * @tsplus pipeable fncts.HashMap set
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function set_<K, V>(map: HashMap<K, V>, key: K, value: 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 fluent fncts.HashMap remove
+ * @tsplus pipeable fncts.HashMap remove
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function remove_<K, V>(map: HashMap<K, V>, key: K): 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 fluent fncts.HashMap removeMany
+ * @tsplus pipeable fncts.HashMap removeMany
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function removeMany_<K, V>(map: HashMap<K, V>, keys: Iterable<K>): 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 fluent fncts.HashMap mutate
+ * @tsplus pipeable fncts.HashMap mutate
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function mutate_<K, V>(map: HashMap<K, V>, f: (map: HashMap<K, V>) => void): 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,189 +136,195 @@ 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 fluent fncts.HashMap update
+ * @tsplus pipeable fncts.HashMap update
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function update_<K, V>(map: HashMap<K, V>, key: K, f: (v: V) => 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 fluent fncts.HashMap forEachWithIndex
+ * @tsplus pipeable fncts.HashMap forEachWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function forEachWithIndex_<K, V>(map: HashMap<K, V>, f: (k: K, v: V, m: HashMap<K, V>) => void): 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 fluent fncts.HashMap forEach
+ * @tsplus pipeable fncts.HashMap forEach
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function forEach_<K, V>(map: HashMap<K, V>, f: (v: V, m: HashMap<K, V>) => void): 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 fluent fncts.HashMap mapWithIndex
+ * @tsplus pipeable fncts.HashMap mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function mapWithIndex_<K, V, A>(fa: HashMap<K, V>, f: (k: K, v: V) => A): 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 fluent fncts.HashMap map
+ * @tsplus pipeable fncts.HashMap map
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function map_<K, V, A>(fa: HashMap<K, V>, f: (v: V) => A): 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 fluent fncts.HashMap flatMapWithIndex
+ * @tsplus pipeable fncts.HashMap flatMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function flatMapWithIndex_<K, V, A>(ma: HashMap<K, V>, f: (k: K, v: V) => HashMap<K, A>): 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 fluent fncts.HashMap flatMap
+ * @tsplus pipeable fncts.HashMap flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function flatMap_<K, V, A>(ma: HashMap<K, V>, f: (v: V) => HashMap<K, A>): 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 fluent fncts.HashMap filterMapWithIndex
+ * @tsplus pipeable fncts.HashMap filterMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterMapWithIndex_<K, A, B>(map: HashMap<K, A>, f: (k: K, a: A) => Maybe<B>): 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 fluent fncts.HashMap filterMap
+ * @tsplus pipeable fncts.HashMap filterMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterMap_<K, A, B>(map: HashMap<K, A>, f: (a: A) => Maybe<B>): 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 fluent fncts.HashMap filterWithIndex
+ * @tsplus pipeable fncts.HashMap filterWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filterWithIndex_<K, A, B extends A>(map: HashMap<K, A>, refinement: RefinementWithIndex<K, A, B>): HashMap<K, B>;
-export declare function filterWithIndex_<K, A>(map: HashMap<K, A>, predicate: PredicateWithIndex<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 fluent fncts.HashMap filter
+ * @tsplus pipeable fncts.HashMap filter
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function filter_<K, A, B extends A>(map: HashMap<K, A>, refinement: Refinement<A, B>): HashMap<K, B>;
-export declare function filter_<K, A>(map: HashMap<K, A>, predicate: Predicate<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 fluent fncts.HashMap partitionMapWithIndex
+ * @tsplus pipeable fncts.HashMap partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare 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>];
+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 fluent fncts.HashMap partitionMap
+ * @tsplus pipeable fncts.HashMap partitionMap
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partitionMap_<K, V, A, B>(map: HashMap<K, V>, f: (a: V) => Either<A, B>): readonly [HashMap<K, A>, 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 fluent fncts.HashMap partitionWithIndex
+ * @tsplus pipeable fncts.HashMap partitionWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partitionWithIndex_<K, V, B extends V>(map: HashMap<K, V>, refinement: RefinementWithIndex<K, V, B>): readonly [HashMap<K, V>, HashMap<K, B>];
-export declare function partitionWithIndex_<K, V>(map: HashMap<K, V>, predicate: PredicateWithIndex<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 fluent fncts.HashMap partition
+ * @tsplus pipeable fncts.HashMap partition
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function partition_<K, V, B extends V>(map: HashMap<K, V>, refinement: Refinement<V, B>): readonly [HashMap<K, V>, HashMap<K, B>];
-export declare function partition_<K, V>(map: HashMap<K, V>, predicate: Predicate<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 fluent fncts.HashMap foldLeftWithIndex
+ * @tsplus pipeable fncts.HashMap foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function foldLeftWithIndex_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (k: K, z: Z, v: V) => Z): 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 fluent fncts.HashMap foldLeft
+ * @tsplus pipeable fncts.HashMap foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function foldLeft_<K, V, Z>(map: HashMap<K, V>, z: Z, f: (z: Z, v: V) => Z): 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"
  */
-export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<KF, A>) => <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: unknown, a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/HashMap/definition").HashMap<KF, B>>;
+export declare 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>>;
 /**
  * @tsplus getter fncts.HashMap traverse
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
+export declare 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>>;
+export declare const traverseWithIndex: P.TraversableWithIndex<HashMapF>["traverseWithIndex"];
 export declare const traverse: P.Traversable<HashMapF>["traverse"];
 /**
- * @tsplus fluent fncts.HashMap unsafeGet
+ * @tsplus pipeable fncts.HashMap unsafeGet
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function unsafeGet_<K, V>(self: HashMap<K, V>, key: K): V | undefined;
+export declare function unsafeGet<K>(key: K): <V>(self: import("@fncts/base/collection/immutable/HashMap/definition").HashMap<K, V>) => V | undefined;
 /**
  * @tsplus getter fncts.HashMap witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"];
+export declare 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>>;
 /**
  * @tsplus getter fncts.HashMap wither
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
+export declare 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>>;
+export declare const witherWithIndex: P.WitherableWithIndex<HashMapF>["witherWithIndex"];
 export declare const wither: P.Witherable<HashMapF>["wither"];
 /**
  * @tsplus getter fncts.HashMap wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"];
+export declare 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>]>;
 /**
  * @tsplus getter fncts.HashMap wilt
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
+export declare function _wilt<K, A>(self: HashMap<K, A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K1, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, Either<B, B2>>) => HKT.Kind<G, GC, K1, Q, W, X, I, S, R, E, readonly [HashMap<K, B>, HashMap<K, B2>]>;
+export declare const wiltWithIndex: P.WitherableWithIndex<HashMapF>["wiltWithIndex"];
 export declare const wilt: P.Witherable<HashMapF>["wilt"];
 /**
- * @tsplus fluent fncts.HashMap unionWith
+ * @tsplus pipeable fncts.HashMap unionWith
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function unionWith_<K, A>(self: HashMap<K, A>, that: Iterable<readonly [K, A]>, f: (x: A, y: A) => A): HashMap<K, A>;
+export declare function unionWith<K, A>(that: Iterable<readonly [K, A]>, f: (x: A, y: A) => A): (self: HashMap<K, A>) => HashMap<K, A>;
 /**
- * @tsplus fluent fncts.HashMap union
+ * @tsplus pipeable fncts.HashMap union
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function union_<K, A>(self: HashMap<K, A>, that: Iterable<readonly [K, A]>): HashMap<K, A>;
+export declare function union<K, A>(that: Iterable<readonly [K, A]>): (self: HashMap<K, A>) => HashMap<K, A>;
 /**
- * @tsplus fluent fncts.HashMap pop
+ * @tsplus pipeable fncts.HashMap pop
  * @tsplus location "@fncts/base/collection/immutable/HashMap/api"
  */
-export declare function pop_<K, A>(map: HashMap<K, A>, k: K): Maybe<readonly [A, 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,6 +12,8 @@ export interface HashMapF extends HKT {
     };
     index: this["K"];
 }
+export declare const TypeId: unique symbol;
+export type TypeId = typeof TypeId;
 /**
  * @tsplus type fncts.HashMap
  * @tsplus companion fncts.HashMapOps
@@ -22,13 +24,20 @@ export declare class HashMap<K, V> implements Iterable<readonly [K, V]>, Hashabl
     readonly config: HashEq<K>;
     root: Node<K, V>;
     size: number;
-    readonly _K: () => K;
-    readonly _A: () => V;
+    readonly _typeId: TypeId;
+    _K: () => K;
+    _A: () => 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;