@fncts/base 0.0.20 → 0.0.22

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

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
 export declare const ImmutableArrayTypeId: unique symbol;
 export type ImmutableArrayTypeId = typeof ImmutableArrayTypeId;
 export interface ImmutableArrayF extends HKT {

package/collection/immutable/ImmutableArray.d.ts

@@ -1,7 +1,6 @@
 export * from "./ImmutableArray/api.js";
 export * from "./ImmutableArray/constructors.js";
 export * from "./ImmutableArray/definition.js";
-export * from "./ImmutableArray/derivations.js";
 export * from "./ImmutableArray/instances.js";
 export * from "./ImmutableArray/api/chunksOf.js";
 export * from "./ImmutableArray/api/slice.js";

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

@@ -1,185 +1,186 @@
 import { These } from "@fncts/base/data/These";
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
+import { HKT } from "@fncts/typelevel/HKT";
 import type { ImmutableNonEmptyArrayF } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray ap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray ap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function ap_<A, B>(self: ImmutableNonEmptyArray<(a: A) => B>, fa: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<B>;
+export declare function ap_<A>(fa: ImmutableNonEmptyArray<A>): <B>(self: ImmutableNonEmptyArray<(a: A) => B>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray append
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray append
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function append_<A, B>(self: ImmutableNonEmptyArray<A>, last: B): ImmutableNonEmptyArray<A | B>;
+export declare function append<B>(last: B): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray align
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray align
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function align_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<These<A, B>>;
+export declare function align<B>(fb: ImmutableNonEmptyArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<import("../../../data/These").These<A, B>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray alignWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray alignWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function alignWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>, f: (_: These<A, B>) => C): ImmutableNonEmptyArray<C>;
+export declare function alignWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (_: These<A, B>) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray flatMap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray flatMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function flatMap_<A, B>(self: ImmutableNonEmptyArray<A>, f: (a: A) => ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<B>;
+export declare function flatMap<A, B>(f: (a: A) => ImmutableNonEmptyArray<B>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray flatMapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray flatMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function flatMapWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<B>;
+export declare function flatMapWithIndex<A, B>(f: (i: number, a: A) => ImmutableNonEmptyArray<B>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray chop
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray chop
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function chop_<A, B>(self: ImmutableNonEmptyArray<A>, f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): ImmutableNonEmptyArray<B>;
+export declare function chop<A, B>(f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray chunksOf
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray chunksOf
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function chunksOf_<A>(self: ImmutableNonEmptyArray<A>, n: number): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
+export declare function chunksOf(n: number): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray concat
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray concat
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function concat_<A, B>(self: ImmutableNonEmptyArray<A>, that: ImmutableArray<B>): ImmutableNonEmptyArray<A | B>;
+export declare function concat<B>(that: ImmutableArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray crossWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray crossWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function crossWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): ImmutableNonEmptyArray<C>;
+export declare function crossWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray cross
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray cross
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function cross_<A, B>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>): ImmutableNonEmptyArray<Zipped.Make<A, B>>;
+export declare function cross<B>(fb: ImmutableNonEmptyArray<B>): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<import("../../../data/Zipped").Zipped.Make<A, B>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray elem
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function elem_<A>(self: ImmutableNonEmptyArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => boolean;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray flatten
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function flatten<A>(self: ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray fold
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray fold
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function fold_<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ S: P.Semigroup<A>): A;
+export declare function fold<A>(/** @tsplus auto */ S: P.Semigroup<A>): (self: ImmutableNonEmptyArray<A>) => A;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldLeft
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldLeft_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ImmutableNonEmptyArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldLeftWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldLeftWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (i: number, b: B, a: A) => B): B;
+export declare function foldLeftWithIndex<A, B>(b: B, f: (i: number, b: B, a: A) => B): (self: ImmutableNonEmptyArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldMapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldMapWithIndex_<A, M>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => M, 
-/** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: ImmutableNonEmptyArray<A>) => M;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldMap
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldMap_<A, M>(self: ImmutableNonEmptyArray<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: ImmutableNonEmptyArray<A>) => M;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldRight
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldRight_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (a: A, b: B) => B): B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: ImmutableNonEmptyArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray foldRightWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray foldRightWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function foldRightWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, b: B, f: (i: number, a: A, b: B) => B): B;
+export declare function foldRightWithIndex<A, B>(b: B, f: (i: number, a: A, b: B) => B): (self: ImmutableNonEmptyArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray group
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray group
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function group<A>(self: ImmutableNonEmptyArray<A>, 
-/** @tsplus auto */ E: P.Eq<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
+export declare function group<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
 export declare function groupSort<A>(as: ImmutableNonEmptyArray<A>, 
 /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<ImmutableNonEmptyArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray isOutOfBound
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray isOutOfBound
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function isOutOfBound_<A>(as: ImmutableNonEmptyArray<A>, i: number): boolean;
+export declare function isOutOfBound(i: number): <A>(as: ImmutableNonEmptyArray<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray map
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray map
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function map_<A, B>(self: ImmutableNonEmptyArray<A>, f: (a: A) => B): ImmutableNonEmptyArray<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray mapWithIndex
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function mapWithIndex_<A, B>(self: ImmutableNonEmptyArray<A>, f: (i: number, a: A) => B): ImmutableNonEmptyArray<B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray max
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray max
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function max<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A;
+export declare function max<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray max
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray max
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function min<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): A;
+export declare function min<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => A;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray mutableClone
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function mutableClone<A>(as: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray prepend
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray prepend
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function prepend_<A, B>(self: ImmutableNonEmptyArray<A>, head: B): ImmutableNonEmptyArray<A | B>;
+export declare function prepend<B>(head: B): <A>(self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<B | A>;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray reverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
 export declare function reverse<A>(self: ImmutableNonEmptyArray<A>): ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray splitAt
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray splitAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function splitAt_<A>(self: ImmutableNonEmptyArray<A>, n: number): readonly [ImmutableNonEmptyArray<A>, ImmutableArray<A>];
+export declare function splitAt(n: number): <A>(self: ImmutableNonEmptyArray<A>) => readonly [ImmutableNonEmptyArray<A>, import("../ImmutableArray").ImmutableArray<A>];
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray sort
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray sort
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function sort<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableNonEmptyArray<A>;
+export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A>;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare const traverseWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: ImmutableNonEmptyArray<A>) => <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <KG, QG, WG, XG, IG, SG, RG, EG, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, ImmutableNonEmptyArray<B>>;
+export declare function _traverseWithIndex<A>(self: ImmutableNonEmptyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableNonEmptyArray<B>>;
 /**
  * @tsplus getter fncts.ImmutableNonEmptyArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
+export declare function _traverse<A>(self: ImmutableNonEmptyArray<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, ImmutableNonEmptyArray<B>>;
+export declare const traverseWithIndex: P.TraversableWithIndex<ImmutableNonEmptyArrayF>["traverseWithIndex"];
 export declare const traverse: P.Traversable<ImmutableNonEmptyArrayF>["traverse"];
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray uniq
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function uniq<A>(self: ImmutableNonEmptyArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableNonEmptyArray<A>;
+export declare function uniq<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableNonEmptyArray zipWith
+ * @tsplus pipeable fncts.ImmutableNonEmptyArray zipWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/api"
  */
-export declare function zipWith_<A, B, C>(self: ImmutableNonEmptyArray<A>, fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): ImmutableNonEmptyArray<C>;
+export declare function zipWith<A, B, C>(fb: ImmutableNonEmptyArray<B>, f: (a: A, b: B) => C): (self: ImmutableNonEmptyArray<A>) => ImmutableNonEmptyArray<C>;

package/collection/immutable/ImmutableNonEmptyArray.d.ts

@@ -1,6 +1,5 @@
 export * from "./ImmutableNonEmptyArray/api.js";
 export * from "./ImmutableNonEmptyArray/constructors.js";
 export * from "./ImmutableNonEmptyArray/definition.js";
-export * from "./ImmutableNonEmptyArray/derivations.js";
 export * from "./ImmutableNonEmptyArray/destructors.js";
 export * from "./ImmutableNonEmptyArray/instances.js";

package/collection/immutable/List/api/foldLeft.d.ts

@@ -1,6 +1,6 @@
 import { List } from "@fncts/base/collection/immutable/List/definition";
 /**
- * @tsplus fluent fncts.List foldLeft
+ * @tsplus pipeable fncts.List foldLeft
  * @tsplus location "@fncts/base/collection/immutable/List/api/foldLeft"
  */
-export declare function foldLeft_<A, B>(self: List<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: List<A>) => B;

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

@@ -1,99 +1,101 @@
 import { List, Cons } from "@fncts/base/collection/immutable/List/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.List flatMap
+ * @tsplus pipeable fncts.List flatMap
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function flatMap_<A, B>(self: List<A>, f: (a: A) => List<B>): List<B>;
+export declare function flatMap<A, B>(f: (a: A) => List<B>): (self: List<A>) => List<B>;
 /**
- * @tsplus fluent fncts.List concat
+ * @tsplus pipeable fncts.List concat
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function concat_<A, B>(self: List<A>, that: List<B>): List<A | B>;
+export declare function concat<B>(that: List<B>): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<B | A>;
 /**
- * @tsplus fluent fncts.List exists
+ * @tsplus pipeable fncts.List some
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function exists_<A>(self: List<A>, p: Predicate<A>): boolean;
+export declare function some<A>(p: Predicate<A>): (self: List<A>) => boolean;
 /**
- * @tsplus fluent fncts.List filter
+ * @tsplus pipeable fncts.List filter
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function filter_<A>(self: List<A>, p: Predicate<A>): List<A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: List<A>) => List<B>;
+export declare function filter<A>(p: Predicate<A>): (self: List<A>) => List<A>;
 /**
- * @tsplus fluent fncts.List forEach
+ * @tsplus pipeable fncts.List forEach
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function forEach_<A, U>(self: List<A>, f: (a: A) => U): void;
+export declare function forEach<A, U>(f: (a: A) => U): (self: List<A>) => void;
 /**
  * @tsplus getter fncts.List head
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function head<A>(self: List<A>): Maybe<A>;
 /**
- * @tsplus fluent fncts.List join
+ * @tsplus pipeable fncts.List join
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function join(self: List<string>, separator: string): string;
+export declare function join(separator: string): (self: List<string>) => string;
 /**
  * @tsplus getter fncts.List length
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function length<A>(list: List<A>): number;
 /**
- * @tsplus fluent fncts.List map
+ * @tsplus pipeable fncts.List map
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function map_<A, B>(self: List<A>, f: (a: A) => B): List<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: List<A>) => List<B>;
 /**
- * @tsplus fluent fncts.List prepend
+ * @tsplus pipeable fncts.List prepend
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function prepend_<A, B>(self: List<A>, elem: B): List<A | B>;
+export declare function prepend<B>(elem: B): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<B | A>;
 /**
  * @tsplus operator fncts.List +
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function prependOperator<A, B>(elem: A, self: List<B>): List<A | B>;
 /**
- * @tsplus fluent fncts.List prependAll
+ * @tsplus pipeable fncts.List prependAll
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function prependAll_<A, B>(self: List<A>, prefix: List<B>): List<A | B>;
+export declare function prependAll<B>(prefix: List<B>): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<B | A>;
 /**
  * @tsplus getter fncts.List reverse
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function reverse<A>(self: List<A>): List<A>;
 /**
- * @tsplus fluent fncts.List sort
+ * @tsplus pipeable fncts.List sort
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function sort<A>(self: List<A>, /** @tsplus auto */ O: P.Ord<A>): List<A>;
+export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: List<A>) => List<A>;
 /**
- * @tsplus fluent fncts.List sortWith
+ * @tsplus pipeable fncts.List sortWith
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function sortWith_<A>(self: List<A>, compare: (x: A, y: A) => P.Ordering): List<A>;
+export declare function sortWith<A>(compare: (x: A, y: A) => P.Ordering): (self: List<A>) => List<A>;
 /**
  * @tsplus getter fncts.List tail
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
 export declare function tail<A>(self: List<A>): Maybe<List<A>>;
 /**
- * @tsplus fluent fncts.List take
+ * @tsplus pipeable fncts.List take
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function take_<A>(self: List<A>, n: number): List<A>;
+export declare function take(n: number): <A>(self: import("@fncts/base/collection/immutable/List/definition").List<A>) => import("@fncts/base/collection/immutable/List/definition").List<A>;
 /**
  * @tsplus getter fncts.List unsafeHead
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function unsafeHead<A>(list: List<A>): A;
+export declare function unsafeHead<A>(self: List<A>): A;
 /**
  * @tsplus getter fncts.List unsafeLast
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function unsafeLast<A>(list: List<A>): A;
+export declare function unsafeLast<A>(self: List<A>): A;

package/collection/immutable/List/constructors.d.ts

@@ -11,7 +11,7 @@ export declare function cons<A>(head: A, tail?: List<A>): Cons<A>;
 export declare function empty<A>(): List<A>;
 /**
  * @tsplus static fncts.ListOps from
- * @tsplus getter fncts.Iterable asList
+ * @tsplus getter fncts.Iterable toList
  * @tsplus location "@fncts/base/collection/immutable/List/constructors"
  */
 export declare function from<A>(prefix: Iterable<A>): List<A>;

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

@@ -5,74 +5,74 @@ import { Queue } from "@fncts/base/collection/immutable/Queue/definition";
  * @tsplus getter fncts.ImmutableQueue length
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function length<A>(queue: Queue<A>): number;
+export declare function length<A>(self: Queue<A>): number;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeHead
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unsafeHead<A>(queue: Queue<A>): A;
+export declare function unsafeHead<A>(self: Queue<A>): A;
 /**
  * @tsplus getter fncts.ImmutableQueue head
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function head<A>(queue: Queue<A>): Maybe<A>;
+export declare function head<A>(self: Queue<A>): Maybe<A>;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeTail
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unsafeTail<A>(queue: Queue<A>): Queue<A>;
+export declare function unsafeTail<A>(self: Queue<A>): Queue<A>;
 /**
  * @tsplus getter fncts.ImmutableQueue tail
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function tail<A>(queue: Queue<A>): Maybe<Queue<A>>;
+export declare function tail<A>(self: Queue<A>): Maybe<Queue<A>>;
 /**
- * @tsplus fluent fncts.ImmutableQueue prepend
+ * @tsplus pipeable fncts.ImmutableQueue prepend
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function prepend_<A, B>(queue: Queue<A>, elem: B): Queue<A | B>;
+export declare function prepend<B>(elem: B): <A>(self: Queue<A>) => Queue<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableQueue enqueue
+ * @tsplus pipeable fncts.ImmutableQueue enqueue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function enqueue_<A, B>(queue: Queue<A>, elem: B): Queue<A | B>;
+export declare function enqueue<B>(elem: B): <A>(self: Queue<A>) => Queue<B | A>;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeDequeue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function unasfeDequeue<A>(queue: Queue<A>): readonly [A, Queue<A>];
+export declare function unasfeDequeue<A>(self: Queue<A>): readonly [A, Queue<A>];
 /**
  * @tsplus getter fncts.ImmutableQueue dequeue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function dequeue<A>(queue: Queue<A>): Maybe<readonly [A, Queue<A>]>;
+export declare function dequeue<A>(self: Queue<A>): Maybe<readonly [A, Queue<A>]>;
 /**
- * @tsplus fluent fncts.ImmutableQueue map
+ * @tsplus pipeable fncts.ImmutableQueue map
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function map_<A, B>(fa: Queue<A>, f: (a: A) => B): Queue<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Queue<A>) => Queue<B>;
 /**
- * @tsplus fluent fncts.ImmutableQueue foldLeft
+ * @tsplus pipeable fncts.ImmutableQueue foldLeft
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function foldLeft_<A, B>(fa: Queue<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Queue<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableQueue exists
+ * @tsplus pipeable fncts.ImmutableQueue some
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function exists_<A>(queue: Queue<A>, p: Predicate<A>): boolean;
+export declare function some<A>(p: Predicate<A>): (self: Queue<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableQueue find
+ * @tsplus pipeable fncts.ImmutableQueue find
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function find_<A>(queue: Queue<A>, p: Predicate<A>): Maybe<A>;
+export declare function find<A>(p: Predicate<A>): (self: Queue<A>) => Maybe<A>;
 /**
- * @tsplus fluent fncts.ImmutableQueue filter
+ * @tsplus pipeable fncts.ImmutableQueue filter
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function filter_<A>(queue: Queue<A>, p: Predicate<A>): Queue<A>;
+export declare function filter<A>(p: Predicate<A>): (self: Queue<A>) => Queue<A>;
 /**
- * @tsplus fluent fncts.ImmutableQueue count
+ * @tsplus pipeable fncts.ImmutableQueue count
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function count_<A>(queue: Queue<A>, p: Predicate<A>): number;
+export declare function count<A>(p: Predicate<A>): (self: Queue<A>) => number;

package/collection/immutable/Queue/guards.d.ts

@@ -3,4 +3,4 @@ import type { Queue } from "./definition.js";
  * @tsplus getter fncts.ImmutableQueue isEmpty
  * @tsplus location "@fncts/base/collection/immutable/Queue/guards"
  */
-export declare function isEmpty<A>(queue: Queue<A>): boolean;
+export declare function isEmpty<A>(self: Queue<A>): boolean;

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

@@ -7,45 +7,45 @@ import { RoseTree } from "./definition.js";
  */
 export declare function make<A>(value: A, forest?: Vector<RoseTree<A>>): RoseTree<A>;
 /**
- * @tsplus fluent fncts.RoseTree foldLeft
+ * @tsplus pipeable fncts.RoseTree foldLeft
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function foldLeft<A, B>(self: RoseTree<A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: RoseTree<A>) => B;
 /**
- * @tsplus fluent fncts.RoseTree foldRight
+ * @tsplus pipeable fncts.RoseTree foldRight
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function foldRight<A, B>(self: RoseTree<A>, b: B, f: (a: A, b: B) => B): B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: RoseTree<A>) => B;
 /**
- * @tsplus fluent fncts.RoseTree map
+ * @tsplus pipeable fncts.RoseTree map
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function map<A, B>(self: RoseTree<A>, f: (a: A) => B): RoseTree<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: RoseTree<A>) => RoseTree<B>;
 /**
- * @tsplus fluent fncts.RoseTree mapAccum
+ * @tsplus pipeable fncts.RoseTree mapAccum
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function mapAccum<A, S, B>(self: RoseTree<A>, s: S, f: (s: S, a: A) => readonly [S, B]): readonly [S, RoseTree<B>];
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [S, B]): (self: RoseTree<A>) => readonly [S, RoseTree<B>];
 /**
- * @tsplus fluent fncts.RoseTree mapWithIndex
+ * @tsplus pipeable fncts.RoseTree mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function mapWithIndex<A, B>(self: RoseTree<A>, f: (i: number, a: A) => B): RoseTree<B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: RoseTree<A>) => RoseTree<B>;
 /**
  * @tsplus static fncts.RoseTreeOps unfold
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
 export declare function unfold<A, B>(b: B, f: (b: B) => readonly [A, Vector<B>]): RoseTree<A>;
 /**
- * @tsplus fluent fncts.RoseTree zipWith
+ * @tsplus pipeable fncts.RoseTree zipWith
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function zipWith<A, B, C>(self: RoseTree<A>, that: RoseTree<B>, f: (a: A, b: B) => C): RoseTree<C>;
+export declare function zipWith<A, B, C>(that: RoseTree<B>, f: (a: A, b: B) => C): (self: RoseTree<A>) => RoseTree<C>;
 /**
- * @tsplus fluent fncts.RoseTree zipWithAccum
+ * @tsplus pipeable fncts.RoseTree zipWithAccum
  * @tsplus location "@fncts/base/collection/immutable/RoseTree/api"
  */
-export declare function zipWithAccum<A, S, B, C>(self: RoseTree<A>, that: RoseTree<B>, s: S, f: (s: S, a: A, b: B) => readonly [S, C]): readonly [S, RoseTree<C>];
+export declare function zipWithAccum<A, S, B, C>(that: RoseTree<B>, s: S, f: (s: S, a: A, b: B) => readonly [S, C]): (self: RoseTree<A>) => readonly [S, RoseTree<C>];
 export interface ZipWithAcc<A, B, C> {
     readonly todoL: Vector<RoseTree<A>>;
     readonly todoR: Vector<RoseTree<B>>;

package/collection/immutable/RoseTree/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 { Vector } from "@fncts/base/collection/immutable/Vector";
 export declare const RoseTreeTypeId: unique symbol;
 export type RoseTreeTypeId = typeof RoseTreeTypeId;