@fncts/base 0.0.20 → 0.0.21

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

@@ -1,6 +1,7 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.ImmutableArray]<_> 10
@@ -12,3 +13,8 @@ export declare function deriveGuard<A extends ImmutableArray<any>>(...[element]:
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
  */
 export declare function deriveDecoder<A extends ImmutableArray<any>>(...[array, elem]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/derivations"
+ */
+export declare function deriveEncoder<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

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/derivations.d.ts

@@ -1,6 +1,7 @@
 import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
 import { Guard } from "@fncts/base/typeclass/Guard";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
+import { Encoder } from "@fncts/base/data/Encoder/definition";
 import type { Check } from "@fncts/typelevel/Check";
 /**
  * @tsplus derive fncts.Guard[fncts.ImmutableNonEmptyArray]<_> 10
@@ -12,3 +13,8 @@ export declare function deriveGuard<A extends ImmutableNonEmptyArray<any>>(...[e
  * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
  */
 export declare function deriveDecoder<A extends ImmutableNonEmptyArray<any>>(...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableNonEmptyArray/derivations"
+ */
+export declare function deriveEncoder<A extends ImmutableNonEmptyArray<any>>(...[element]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;

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

@@ -3,90 +3,90 @@ import { Predicate } from "@fncts/base/data/Predicate/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 exists
  * @tsplus location "@fncts/base/collection/immutable/List/api"
  */
-export declare function exists_<A>(self: List<A>, p: Predicate<A>): boolean;
+export declare function exists<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>(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"

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

@@ -27,15 +27,15 @@ export declare function unsafeTail<A>(queue: Queue<A>): Queue<A>;
  */
 export declare function tail<A>(queue: 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>(queue: 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>(queue: Queue<A>) => Queue<B | A>;
 /**
  * @tsplus getter fncts.ImmutableQueue unsafeDequeue
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
@@ -47,32 +47,32 @@ export declare function unasfeDequeue<A>(queue: Queue<A>): readonly [A, Queue<A>
  */
 export declare function dequeue<A>(queue: 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): (fa: 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): (fa: Queue<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableQueue exists
+ * @tsplus pipeable fncts.ImmutableQueue exists
  * @tsplus location "@fncts/base/collection/immutable/Queue/api"
  */
-export declare function exists_<A>(queue: Queue<A>, p: Predicate<A>): boolean;
+export declare function exists<A>(p: Predicate<A>): (queue: 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>): (queue: 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>): (queue: 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>): (queue: Queue<A>) => number;

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