@fncts/base 0.0.20 → 0.0.21

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

@@ -34,34 +34,34 @@ export declare function make<K, V>(...items: readonly (readonly [K, V])[]): Hash
 export declare function makeDefault<K, V>(): HashMap<K, V>;
 /**
  * Makes a new map from a Foldable of key-value pairs
- * @tsplus fluent fncts.HashMapOps fromFoldable
+ * @tsplus pipeable fncts.HashMapOps fromFoldable
  * @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>;
 /**
  * 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>(map: 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>(map: 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 hashHash
  * @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>(map: 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>(map: 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>): (map: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Alter the value stored for `key` in `map` using function `f` using internal hash function.
  *
@@ -82,28 +82,28 @@ 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>): (map: 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): (map: 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>(map: 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>(map: 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
@@ -118,10 +118,10 @@ export declare function beginMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
 export declare function endMutation<K, V>(map: HashMap<K, V>): HashMap<K, V>;
 /**
  * Mutate `map` within the context of `f`.
- * @tsplus fluent fncts.HashMap mutate
+ * @tsplus pipeable fncts.HashMap mutate
  * @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): (map: HashMap<K, V>) => HashMap<K, V>;
 /**
  * Get an IterableIterator of the map keys
  * @tsplus getter fncts.HashMap keys
@@ -160,46 +160,46 @@ export declare function toArray<K, V>(map: HashMap<K, V>): Array<readonly [K, V]
 export declare function values<K, V>(map: HashMap<K, V>): IterableIterator<V>;
 /**
  * Update a value if exists
- * @tsplus fluent fncts.HashMap update
+ * @tsplus pipeable fncts.HashMap update
  * @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): (map: 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): (map: 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): (map: 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): (fa: 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>(fa: 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>): (ma: 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>): (ma: HashMap<K, V>) => HashMap<K, A>;
 /**
  * Removes values that are `Nothing`
  * @tsplus getter fncts.HashMap compact
@@ -214,111 +214,117 @@ export declare function compact<K, A>(map: HashMap<K, Maybe<A>>): HashMap<K, A>;
 export declare function separate<K, A, B>(map: 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>): (map: 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>(map: 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>): (map: HashMap<K, A>) => HashMap<K, B>;
+export declare function filterWithIndex<K, A>(predicate: PredicateWithIndex<K, A>): (map: 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>(map: HashMap<K, A>) => HashMap<K, B>;
+export declare function filter<A>(predicate: Predicate<A>): <K>(map: 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>): (map: 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>(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>];
 /**
- * @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>): (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>];
 /**
- * @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>(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>];
 /**
  * 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): (map: 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>(map: 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>(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>]>;

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

@@ -5,10 +5,10 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.HashSet add
+ * @tsplus pipeable fncts.HashSet add
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function add_<A>(set: HashSet<A>, value: A): HashSet<A>;
+export declare function add<A>(value: A): (set: HashSet<A>) => HashSet<A>;
 /**
  * Mark `set` as mutable.
  * @tsplus getter fncts.HashSet beginMutation
@@ -23,15 +23,15 @@ export declare function beginMutation<K>(set: HashSet<K>): HashSet<K>;
 export declare function endMutation<K>(set: HashSet<K>): HashSet<K>;
 /**
  * Appy f to each element
- * @tsplus fluent fncts.HashSet forEach
+ * @tsplus pipeable fncts.HashSet forEach
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function forEach_<V>(map: HashSet<V>, f: (v: V, m: HashSet<V>) => void): void;
+export declare function forEach<V>(f: (v: V, m: HashSet<V>) => void): (map: HashSet<V>) => void;
 /**
- * @tsplus fluent fncts.HashSet has
+ * @tsplus pipeable fncts.HashSet has
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function has_<A>(set: HashSet<A>, value: A): boolean;
+export declare function has<A>(value: A): (set: HashSet<A>) => boolean;
 /**
  * @tsplus static fncts.HashSetOps make
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
@@ -49,15 +49,15 @@ export declare function makeDefault<A>(): HashSet<A>;
 export declare function fromDefault<A>(...values: ReadonlyArray<A>): HashSet<A>;
 /**
  * Mutate `set` within the context of `f`.
- * @tsplus fluent fncts.HashSet mutate
+ * @tsplus pipeable fncts.HashSet mutate
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mutate_<A>(set: HashSet<A>, transient: (set: HashSet<A>) => void): HashSet<A>;
+export declare function mutate<A>(transient: (set: HashSet<A>) => void): (self: HashSet<A>) => HashSet<A>;
 /**
- * @tsplus fluent fncts.HashSet remove
+ * @tsplus pipeable fncts.HashSet remove
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function remove_<A>(set: HashSet<A>, value: A): HashSet<A>;
+export declare function remove<A>(value: A): (set: HashSet<A>) => HashSet<A>;
 /**
  * Calculate the number of keys pairs in a set
  * @tsplus getter fncts.HashSet size
@@ -66,29 +66,29 @@ export declare function remove_<A>(set: HashSet<A>, value: A): HashSet<A>;
 export declare function size<A>(set: HashSet<A>): number;
 /**
  * If element is present remove it, if not add it
- * @tsplus fluent fncts.HashSet toggle
+ * @tsplus pipeable fncts.HashSet toggle
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function toggle_<A>(set: HashSet<A>, a: A): HashSet<A>;
+export declare function toggle<A>(a: A): (set: HashSet<A>) => HashSet<A>;
 /**
  * Projects a Set through a function
  */
-export declare function map_<B>(C: P.HashEq<B>): <A>(fa: HashSet<A>, f: (x: A) => B) => HashSet<B>;
+export declare function map<B>(C: P.HashEq<B>): <A>(f: (x: A) => B) => (fa: HashSet<A>) => HashSet<B>;
 /**
  * Projects a Set through a function
- * @tsplus fluent fncts.HashSet map
+ * @tsplus pipeable fncts.HashSet map
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function mapDefault<A, B>(self: HashSet<A>, f: (a: A) => B): HashSet<B>;
+export declare function mapDefault<A, B>(f: (a: A) => B): (self: HashSet<A>) => HashSet<B>;
 /**
  * Map + Flatten
  */
-export declare function flatMap_<B>(C: P.HashEq<B>): <A>(set: HashSet<A>, f: (x: A) => Iterable<B>) => HashSet<B>;
+export declare function flatMap<B>(C: P.HashEq<B>): <A>(f: (x: A) => Iterable<B>) => (self: HashSet<A>) => HashSet<B>;
 /**
- * @tsplus fluent fncts.HashSet flatMap
+ * @tsplus pipeable fncts.HashSet flatMap
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function flatMapDefault<A, B>(self: HashSet<A>, f: (a: A) => Iterable<B>): HashSet<B>;
+export declare function flatMapDefault<A, B>(f: (a: A) => Iterable<B>): (self: HashSet<A>) => HashSet<B>;
 /**
  * Creates an equal for a set
  * @tsplus static fncts.HashSetOps getEq
@@ -97,74 +97,78 @@ export declare function flatMapDefault<A, B>(self: HashSet<A>, f: (a: A) => Iter
 export declare function getEq<A>(): P.Eq<HashSet<A>>;
 /**
  * Filter set values using predicate
- * @tsplus fluent fncts.HashSet filter
+ * @tsplus pipeable fncts.HashSet filter
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function filter_<A, B extends A>(set: HashSet<A>, refinement: Refinement<A, B>): HashSet<B>;
-export declare function filter_<A>(set: HashSet<A>, predicate: Predicate<A>): HashSet<A>;
-export declare function filterMap_<B>(B: P.HashEq<B>): <A>(fa: HashSet<A>, f: (a: A) => Maybe<B>) => HashSet<B>;
+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>;
 /**
  * Partition set values using predicate
- * @tsplus fluent fncts.HashSet partition
+ * @tsplus pipeable fncts.HashSet partition
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function partition_<A, B extends A>(self: HashSet<A>, p: Refinement<A, B>): readonly [HashSet<A>, HashSet<B>];
-export declare function partition_<A>(self: HashSet<A>, p: Predicate<A>): readonly [HashSet<A>, HashSet<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<B>];
+export declare function partition<A>(p: Predicate<A>): (self: HashSet<A>) => readonly [HashSet<A>, HashSet<A>];
 /**
  * Partition set values using predicate
  */
-export declare function partitionMap_<B, C>(B: P.HashEq<B>, C: P.HashEq<C>): <A>(self: HashSet<A>, f: (a: A) => Either<B, C>) => readonly [HashSet<B>, HashSet<C>];
+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>];
 /**
  * Reduce a state over the set elements
- * @tsplus fluent fncts.HashSet foldLeft
+ * @tsplus pipeable fncts.HashSet foldLeft
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function foldLeft_<A, B>(fa: HashSet<A>, b: B, f: (b: B, v: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, v: A) => B): (fa: HashSet<A>) => B;
 /**
- * @tsplus fluent fncts.HashSet join
+ * @tsplus pipeable fncts.HashSet join
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function join_(self: HashSet<string>, separator: string): string;
+export declare function join(separator: string): (self: HashSet<string>) => string;
 /**
  * Form the set difference
- * @tsplus fluent fncts.HashSet difference
+ * @tsplus pipeable fncts.HashSet difference
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function difference_<A>(x: HashSet<A>, y: Iterable<A>): HashSet<A>;
+export declare function difference<A>(y: Iterable<A>): (x: HashSet<A>) => HashSet<A>;
 /**
  * true if all elements match predicate
- * @tsplus fluent fncts.HashSet every
+ * @tsplus pipeable fncts.HashSet every
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function every_<A>(self: HashSet<A>, predicate: Predicate<A>): boolean;
+export declare function every<A>(predicate: Predicate<A>): (self: HashSet<A>) => boolean;
 /**
  * The set of elements which are in both the first and second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ * @tsplus pipeable fncts.HashSet intersection
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function intersection_<A>(self: HashSet<A>, that: Iterable<A>): HashSet<A>;
+export declare function intersection<A>(that: Iterable<A>): (self: HashSet<A>) => HashSet<A>;
 /**
  * `true` if and only if every element in the first set is an element of the second set,
  *
  * the hash and equal of the 2 sets has to be the same
+ * @tsplus pipeable fncts.HashSet isSubset
+ * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function isSubset_<A>(x: HashSet<A>, y: HashSet<A>): boolean;
+export declare function isSubset<A>(y: HashSet<A>): (x: HashSet<A>) => boolean;
 /**
  * true if one or more elements match predicate
- * @tsplus fluent fncts.HashSet exists
+ * @tsplus pipeable fncts.HashSet exists
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function exists_<A>(set: HashSet<A>, predicate: Predicate<A>): boolean;
+export declare function exists<A>(predicate: Predicate<A>): (set: HashSet<A>) => boolean;
 /**
  * Form the union of two sets,
  *
  * the hash and equal of the 2 sets has to be the same
- * @tsplus fluent fncts.HashSet union
+ * @tsplus pipeable fncts.HashSet union
  * @tsplus location "@fncts/base/collection/immutable/HashSet/api"
  */
-export declare function union_<A>(l: HashSet<A>, r: Iterable<A>): HashSet<A>;
+export declare function union<A>(r: Iterable<A>): (l: HashSet<A>) => HashSet<A>;
 /**
  * @tsplus static 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>(set: HashSet<A>, O: P.Ord<A>): ReadonlyArray<A>;

package/collection/immutable/ImmutableArray/api/chunksOf.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray chunksOf
+ * @tsplus pipeable fncts.ImmutableArray chunksOf
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/chunksOf"
  */
-export declare function chunksOf_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<ImmutableArray<A>>;
+export declare function chunksOf(n: number): <A>(self: import("../definition").ImmutableArray<A>) => import("../definition").ImmutableArray<import("../definition").ImmutableArray<A>>;

package/collection/immutable/ImmutableArray/api/slice.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray slice
+ * @tsplus pipeable fncts.ImmutableArray slice
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/slice"
  */
-export declare function slice_<A>(self: ImmutableArray<A>, start?: number, end?: number): ImmutableArray<A>;
+export declare function slice(start?: number, end?: number): <A>(self: import("../definition").ImmutableArray<A>) => import("../definition").ImmutableArray<A>;

package/collection/immutable/ImmutableArray/api/splitAt.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray splitAt
+ * @tsplus pipeable fncts.ImmutableArray splitAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitAt"
  */
-export declare function splitAt_<A>(as: ImmutableArray<A>, n: number): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function splitAt(n: number): <A>(as: import("../definition").ImmutableArray<A>) => readonly [import("../definition").ImmutableArray<A>, import("../definition").ImmutableArray<A>];

package/collection/immutable/ImmutableArray/api/splitWhere.d.ts

@@ -1,7 +1,7 @@
-import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 /**
- * @tsplus fluent fncts.ImmutableArray splitWhere
+ * @tsplus pipeable fncts.ImmutableArray splitWhere
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api/splitWhere"
  */
-export declare function splitWhere_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function splitWhere<A>(p: Predicate<A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];