@fncts/base 0.0.20 → 0.0.21

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

@@ -8,44 +8,45 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { Predicate, PredicateWithIndex } from "@fncts/base/data/Predicate/definition";
 import { Refinement, RefinementWithIndex } from "@fncts/base/data/Refinement/definition";
+import { HKT } from "@fncts/typelevel/HKT";
 import type { ImmutableArrayF } from "@fncts/base/collection/immutable/ImmutableArray/definition";
 import type { Monoid } from "@fncts/base/typeclass";
 import * as P from "@fncts/base/typeclass";
 /**
- * @tsplus fluent fncts.ImmutableArray alignWith
+ * @tsplus pipeable fncts.ImmutableArray alignWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function alignWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (_: These<A, B>) => C): ImmutableArray<C>;
+export declare function alignWith<A, B, C>(fb: ImmutableArray<B>, f: (_: These<A, B>) => C): (self: ImmutableArray<A>) => ImmutableArray<C>;
 /**
- * @tsplus fluent fncts.ImmutableArray align
+ * @tsplus pipeable fncts.ImmutableArray align
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function align_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<These<A, B>>;
+export declare function align<B>(fb: ImmutableArray<B>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<import("../../../data/These").These<A, B>>;
 /**
- * @tsplus fluent fncts.ImmutableArray alt
+ * @tsplus pipeable fncts.ImmutableArray alt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function alt_<A, B>(self: ImmutableArray<A>, that: Lazy<ImmutableArray<B>>): ImmutableArray<A | B>;
+export declare function alt<B>(that: Lazy<ImmutableArray<B>>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableArray ap
+ * @tsplus pipeable fncts.ImmutableArray ap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function ap_<A, B>(self: ImmutableArray<(a: A) => B>, fa: ImmutableArray<A>): ImmutableArray<B>;
+export declare function ap<A>(fa: ImmutableArray<A>): <B>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<(a: A) => B>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray append
+ * @tsplus pipeable fncts.ImmutableArray append
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function append_<A, B>(self: ImmutableArray<A>, last: B): ImmutableArray<A | B>;
+export declare function append<B>(last: B): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableArray crossWith
+ * @tsplus pipeable fncts.ImmutableArray crossWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function crossWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (a: A, b: B) => C): ImmutableArray<C>;
+export declare function crossWith<A, B, C>(fb: ImmutableArray<B>, f: (a: A, b: B) => C): (self: ImmutableArray<A>) => ImmutableArray<C>;
 /**
- * @tsplus fluent fncts.ImmutableArray cross
+ * @tsplus pipeable fncts.ImmutableArray cross
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function cross_<A, B>(self: ImmutableArray<A>, fb: ImmutableArray<B>): ImmutableArray<Zipped.Make<A, B>>;
+export declare function cross<B>(fb: ImmutableArray<B>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<import("../../../data/Zipped").Zipped.Make<A, B>>;
 /**
  * @tsplus static fncts.ImmutableArrayOps chainRecDepthFirst
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -57,15 +58,15 @@ export declare function chainRecDepthFirst<A, B>(a: A, f: (a: A) => ImmutableArr
  */
 export declare function chainRecBreadthFirst<A, B>(a: A, f: (a: A) => ImmutableArray<Either<A, B>>): ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray flatMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray flatMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function flatMapWithIndex_<A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => ImmutableArray<B>): ImmutableArray<B>;
+export declare function flatMapWithIndex<A, B>(f: (i: number, a: A) => ImmutableArray<B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray flatMap
+ * @tsplus pipeable fncts.ImmutableArray flatMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function flatMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => ImmutableArray<B>): ImmutableArray<B>;
+export declare function flatMap<A, B>(f: (a: A) => ImmutableArray<B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
  * @tsplus getter fncts.ImmutableArray flatten
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -75,20 +76,15 @@ export declare function flatten<A>(self: ImmutableArray<ImmutableArray<A>>): Imm
  * A useful recursion pattern for processing a `Array` to produce a new `Array`,
  * often used for "chopping" up the input `Array`. Typically chop is called with some function
  * that will consume an initial prefix of the `Array` and produce a value and the rest of the `Array`.
- * @tsplus fluent fncts.ImmutableArray chop
- * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
- */
-export declare function chop_<A, B>(as: ImmutableArray<A>, f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): ImmutableArray<B>;
-/**
  * @tsplus pipeable fncts.ImmutableArray chop
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const chop: <A, B>(f: (as: import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>) => readonly [B, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>]) => (as: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>;
+export declare function chop<A, B>(f: (as: ImmutableNonEmptyArray<A>) => readonly [B, ImmutableArray<A>]): (as: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray collectWhile
+ * @tsplus pipeable fncts.ImmutableArray collectWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function collectWhile_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B>;
+export declare function collectWhile<A, B>(f: (a: A) => Maybe<B>): (as: ImmutableArray<A>) => ImmutableArray<B>;
 /**
  * @tsplus static fncts.ImmutableArrayOps comprehension
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -98,219 +94,216 @@ export declare function comprehension<A, B, C, R>(input: [ImmutableArray<A>, Imm
 export declare function comprehension<A, B, R>(input: [ImmutableArray<A>, ImmutableArray<B>], f: (a: A, b: B) => R, g?: (a: A, b: B) => boolean): ImmutableArray<R>;
 export declare function comprehension<A, R>(input: [ImmutableArray<A>], f: (a: A) => R, g?: (a: A) => boolean): ImmutableArray<R>;
 /**
- * @tsplus fluent fncts.ImmutableArray concat
- * @tsplus operator fncts.ImmutableArray +
+ * @tsplus pipeable fncts.ImmutableArray concat
+ * @tsplus pipeable-operator fncts.ImmutableArray +
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function concat_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<A | B>;
+export declare function concat<B>(that: ImmutableArray<B>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableArray deleteAt
+ * @tsplus pipeable fncts.ImmutableArray deleteAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function deleteAt_<A>(as: ImmutableArray<A>, i: number): Maybe<ImmutableArray<A>>;
+export declare function deleteAt(i: number): <A>(as: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("../../../data/Maybe").Maybe<import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray difference
+ * @tsplus pipeable fncts.ImmutableArray difference
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function difference_<A>(self: ImmutableArray<A>, ys: ImmutableArray<A>, 
-/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
+export declare function difference<A>(ys: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray drop
+ * @tsplus pipeable fncts.ImmutableArray drop
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function drop_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+export declare function drop(n: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray dropLast
+ * @tsplus pipeable fncts.ImmutableArray dropLast
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function dropLast_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+export declare function dropLast(n: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray dropWhile
+ * @tsplus pipeable fncts.ImmutableArray dropWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function dropWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+export declare function dropWhile<A>(p: Predicate<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray dropLastWhile
+ * @tsplus pipeable fncts.ImmutableArray dropLastWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function dropLastWhile_<A>(as: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+export declare function dropLastWhile<A>(p: Predicate<A>): (as: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * Test if a value is a member of an array. Takes an `Eq<A>` as a single
  * argument which returns the function to use to search for a value of type `A` in
  * an array of type `ImmutableArray<A>`.
- * @tsplus fluent fncts.ImmutableArray elem
+ * @tsplus pipeable fncts.ImmutableArray elem
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function elem_<A>(as: ImmutableArray<A>, a: A, /** @tsplus auto */ E: P.Eq<A>): boolean;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: P.Eq<A>): (as: ImmutableArray<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableArray every
+ * @tsplus pipeable fncts.ImmutableArray every
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function every_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): self is ImmutableArray<B>;
-export declare function every_<A>(self: ImmutableArray<A>, p: Predicate<A>): boolean;
+export declare function every<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => self is ImmutableArray<B>;
+export declare function every<A>(p: Predicate<A>): (self: ImmutableArray<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableArray everyWithIndex
+ * @tsplus pipeable fncts.ImmutableArray everyWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function everyWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): self is ImmutableArray<B>;
-export declare function everyWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): boolean;
+export declare function everyWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ImmutableArray<A>) => self is ImmutableArray<B>;
+export declare function everyWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableArray exists
+ * @tsplus pipeable fncts.ImmutableArray exists
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function exists_<A>(self: ImmutableArray<A>, p: Predicate<A>): self is ImmutableNonEmptyArray<A>;
+export declare function exists<A>(p: Predicate<A>): (self: ImmutableArray<A>) => self is import("../ImmutableNonEmptyArray").ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray filter
+ * @tsplus pipeable fncts.ImmutableArray filter
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function filter_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
-export declare function filter_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export declare function filter<A>(p: Predicate<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray filterWithIndex
+ * @tsplus pipeable fncts.ImmutableArray filterWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function filterWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): ImmutableArray<B>;
-export declare function filterWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): ImmutableArray<A>;
+export declare function filterWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export declare function filterWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray filterMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray filterMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function filterMapWithIndex_<A, B>(fa: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): ImmutableArray<B>;
+export declare function filterMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (fa: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray filterMap
+ * @tsplus pipeable fncts.ImmutableArray filterMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function filterMap_<A, B>(self: ImmutableArray<A>, f: (a: A) => Maybe<B>): ImmutableArray<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray find
+ * @tsplus pipeable fncts.ImmutableArray find
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function find_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
-export declare function find_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
+export declare function find<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => Maybe<B>;
+export declare function find<A>(p: Predicate<A>): (self: ImmutableArray<A>) => Maybe<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray findIndex
+ * @tsplus pipeable fncts.ImmutableArray findIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findIndex_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): Maybe<number>;
+export declare function findIndex<A>(predicate: Predicate<A>): (as: ImmutableArray<A>) => Maybe<number>;
 /**
- * @tsplus fluent fncts.ImmutableArray findWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findWithIndex_<A, B extends A>(as: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): Maybe<B>;
-export declare function findWithIndex_<A>(as: ImmutableArray<A>, p: PredicateWithIndex<number, A>): Maybe<A>;
+export declare function findWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (as: ImmutableArray<A>) => Maybe<B>;
+export declare function findWithIndex<A>(p: PredicateWithIndex<number, A>): (as: ImmutableArray<A>) => Maybe<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray findMap
+ * @tsplus pipeable fncts.ImmutableArray findMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+export declare function findMap<A, B>(f: (a: A) => Maybe<B>): (as: ImmutableArray<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray findMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (index: number, a: A) => Maybe<B>): Maybe<B>;
+export declare function findMapWithIndex<A, B>(f: (index: number, a: A) => Maybe<B>): (as: ImmutableArray<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray findLast
+ * @tsplus pipeable fncts.ImmutableArray findLast
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findLast_<A, B extends A>(as: ImmutableArray<A>, p: Refinement<A, B>): Maybe<B>;
-export declare function findLast_<A>(as: ImmutableArray<A>, p: Predicate<A>): Maybe<A>;
+export declare function findLast<A, B extends A>(p: Refinement<A, B>): (as: ImmutableArray<A>) => Maybe<B>;
+export declare function findLast<A>(p: Predicate<A>): (as: ImmutableArray<A>) => Maybe<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray findLastIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findLastIndex_<A>(self: ImmutableArray<A>, p: Predicate<A>): Maybe<number>;
+export declare function findLastIndex<A>(p: Predicate<A>): (self: ImmutableArray<A>) => Maybe<number>;
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMap
+ * @tsplus pipeable fncts.ImmutableArray findLastMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findLastMap_<A, B>(as: ImmutableArray<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+export declare function findLastMap<A, B>(f: (a: A) => Maybe<B>): (as: ImmutableArray<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray findLastMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray findLastMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function findLastMapWithIndex_<A, B>(as: ImmutableArray<A>, f: (i: number, a: A) => Maybe<B>): Maybe<B>;
+export declare function findLastMapWithIndex<A, B>(f: (i: number, a: A) => Maybe<B>): (as: ImmutableArray<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndex
- * @tsplus fluent fncts.MutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndex
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldLeftWithIndex_<A, B>(self: ImmutableArray<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: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeft
- * @tsplus fluent fncts.MutableArray foldLeft
+ * @tsplus pipeable fncts.ImmutableArray foldLeft
+ * @tsplus pipeable fncts.MutableArray foldLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldLeft_<A, B>(self: ImmutableArray<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: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWhile
- * @tsplus fluent fncts.MutableArray foldLeftWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldLeftWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (b: B, a: A) => B): B;
+export declare function foldLeftWhile<A, B>(b: B, p: Predicate<B>, f: (b: B, a: A) => B): (self: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldLeftWithIndexWhile
- * @tsplus fluent fncts.MutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldLeftWithIndexWhile
+ * @tsplus pipeable fncts.MutableArray foldLeftWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldLeftWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): B;
+export declare function foldLeftWithIndexWhile<A, B>(b: B, p: Predicate<B>, f: (i: number, b: B, a: A) => B): (self: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray fold
+ * @tsplus pipeable fncts.ImmutableArray fold
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function fold<M>(self: ImmutableArray<M>, /** @tsplus auto */ M: Monoid<M>): M;
+export declare function fold<M>(/** @tsplus auto */ M: Monoid<M>): (self: ImmutableArray<M>) => M;
 /**
- * @tsplus fluent fncts.ImmutableArray foldMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldMapWithIndex_<A, M>(self: ImmutableArray<A>, f: (i: number, a: A) => M, 
-/** @tsplus auto */ M: Monoid<M>): M;
+export declare function foldMapWithIndex<A, M>(f: (i: number, a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: ImmutableArray<A>) => M;
 /**
- * @tsplus fluent fncts.ImmutableArray foldMap
+ * @tsplus pipeable fncts.ImmutableArray foldMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldMap_<A, M>(self: ImmutableArray<A>, f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: Monoid<M>): (self: ImmutableArray<A>) => M;
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndex
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldRightWithIndex_<A, B>(self: ImmutableArray<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: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldRight
+ * @tsplus pipeable fncts.ImmutableArray foldRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldRight_<A, B>(self: ImmutableArray<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: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldRighWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRighWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldRightWhile_<A, B>(self: ImmutableArray<A>, b: B, p: Predicate<B>, f: (a: A, b: B) => B): B;
+export declare function foldRightWhile<A, B>(b: B, p: Predicate<B>, f: (a: A, b: B) => B): (self: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray foldRightWithIndexWhile
+ * @tsplus pipeable fncts.ImmutableArray foldRightWithIndexWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function foldRightWithIndexWhile_<A, B>(self: ImmutableArray<A>, b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B): B;
+export declare function foldRightWithIndexWhile<A, B>(b: B, predicate: Predicate<B>, f: (i: number, a: A, b: B) => B): (self: ImmutableArray<A>) => B;
 /**
- * @tsplus fluent fncts.ImmutableArray forEach
+ * @tsplus pipeable fncts.ImmutableArray forEach
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function forEach_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): void;
+export declare function forEach<A, B>(f: (a: A) => B): (self: ImmutableArray<A>) => void;
 /**
- * @tsplus fluent fncts.ImmutableArray get
- * @tsplus fluent fncts.MutableArray get
+ * @tsplus pipeable fncts.ImmutableArray get
+ * @tsplus pipeable fncts.MutableArray get
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function get_<A>(self: ImmutableArray<A>, i: number): Maybe<A>;
-export declare function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<ImmutableNonEmptyArray<A>>;
+export declare function get(i: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("../../../data/Maybe").Maybe<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray group
+ * @tsplus pipeable fncts.ImmutableArray group
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function chopSelf<A>(self: ImmutableArray<A>, E: P.Eq<A>): ImmutableArray<ImmutableNonEmptyArray<A>>;
+export declare function group<A>(E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<ImmutableNonEmptyArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray groupBy
+ * @tsplus pipeable fncts.ImmutableArray groupBy
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function groupBy_<A>(self: ImmutableArray<A>, f: (a: A) => string): Readonly<Record<string, ImmutableNonEmptyArray<A>>>;
+export declare function groupBy<A>(f: (a: A) => string): (self: ImmutableArray<A>) => Readonly<Record<string, ImmutableNonEmptyArray<A>>>;
 /**
  * @tsplus getter fncts.ImmutableArray head
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -322,32 +315,35 @@ export declare function head<A>(self: ImmutableArray<A>): Maybe<A>;
  */
 export declare function init<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray insertAt
+ * @tsplus pipeable fncts.ImmutableArray insertAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function insertAt_<A>(self: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableNonEmptyArray<A>>;
+export declare function insertAt<A>(i: number, a: A): (self: ImmutableArray<A>) => Maybe<ImmutableNonEmptyArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray intersection
+ * @tsplus pipeable fncts.ImmutableArray intersection
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function intersection_<A>(self: ImmutableArray<A>, that: ImmutableArray<A>, 
-/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
-export declare function intersperse_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
+export declare function intersection<A>(that: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
+/**
+ * @tsplus pipeable fncts.ImmutableArray intersperse
+ * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
+ */
+export declare function intersperse<A>(a: A): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus fluent fncts.ImmutableArray isEmpty
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function isEmpty<A>(self: ImmutableArray<A>): boolean;
 /**
- * @tsplus fluent fncts.ImmutableArray isOutOfBound
+ * @tsplus pipeable fncts.ImmutableArray isOutOfBound
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function isOutOfBound_<A>(self: ImmutableArray<A>, i: number): boolean;
+export declare function isOutOfBound(i: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => boolean;
 /**
- * @tsplus fluent fncts.ImmutableArray join
+ * @tsplus pipeable fncts.ImmutableArray join
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function join(self: ImmutableArray<string>, separator: string): string;
+export declare function join(separator: string): (self: ImmutableArray<string>) => string;
 /**
  * @tsplus getter fncts.ImmutableArray last
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -364,68 +360,67 @@ export declare function length<A>(self: ImmutableArray<A>): number;
  */
 export declare function lefts<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<E>;
 /**
- * @tsplus fluent fncts.ImmutableArray map
+ * @tsplus pipeable fncts.ImmutableArray map
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function map_<A, B>(self: ImmutableArray<A>, f: (a: A) => B): ImmutableArray<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray mapAccum
+ * @tsplus pipeable fncts.ImmutableArray mapAccum
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function mapAccum_<A, S, B>(self: ImmutableArray<A>, s: S, f: (s: S, a: A) => readonly [B, S]): readonly [ImmutableArray<B>, S];
+export declare function mapAccum<A, S, B>(s: S, f: (s: S, a: A) => readonly [B, S]): (self: ImmutableArray<A>) => readonly [ImmutableArray<B>, S];
 /**
- * @tsplus fluent fncts.ImmutableArray mapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray mapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function mapWithIndex_<A, B>(self: ImmutableArray<A>, f: (i: number, a: A) => B): ImmutableArray<B>;
+export declare function mapWithIndex<A, B>(f: (i: number, a: A) => B): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray modifyAt
+ * @tsplus pipeable fncts.ImmutableArray modifyAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function modifyAt_<A>(self: ImmutableArray<A>, i: number, f: (a: A) => A): Maybe<ImmutableArray<A>>;
+export declare function modifyAt<A>(i: number, f: (a: A) => A): (self: ImmutableArray<A>) => Maybe<ImmutableArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray mutate
+ * @tsplus pipeable fncts.ImmutableArray mutate
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function mutate_<A>(self: ImmutableArray<A>, f: (self: Array<A>) => void): ImmutableArray<A>;
+export declare function mutate<A>(f: (self: Array<A>) => void): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray mutableClone
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function mutableClone<A>(self: ImmutableArray<A>): Array<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray partitionWithIndex
+ * @tsplus pipeable fncts.ImmutableArray partitionWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function partitionWithIndex_<A, B extends A>(self: ImmutableArray<A>, p: RefinementWithIndex<number, A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export declare function partitionWithIndex_<A>(self: ImmutableArray<A>, p: PredicateWithIndex<number, A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function partitionWithIndex<A, B extends A>(p: RefinementWithIndex<number, A, B>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function partitionWithIndex<A>(p: PredicateWithIndex<number, A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
 /**
- * @tsplus fluent fncts.ImmutableArray partition
+ * @tsplus pipeable fncts.ImmutableArray partition
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function partition_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export declare function partition_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function partition<A>(p: Predicate<A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
 /**
- * @tsplus fluent fncts.ImmutableArray partitionMapWithIndex
+ * @tsplus pipeable fncts.ImmutableArray partitionMapWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function partitionMapWithIndex_<A, B, C>(self: ImmutableArray<A>, f: (i: number, a: A) => Either<B, C>): readonly [ImmutableArray<B>, ImmutableArray<C>];
+export declare function partitionMapWithIndex<A, B, C>(f: (i: number, a: A) => Either<B, C>): (self: ImmutableArray<A>) => readonly [ImmutableArray<B>, ImmutableArray<C>];
 /**
- * @tsplus fluent fncts.ImmutableArray partitionMap
+ * @tsplus pipeable fncts.ImmutableArray partitionMap
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function partitionMap_<A, B, C>(self: ImmutableArray<A>, f: (a: A) => Either<B, C>): readonly [ImmutableArray<B>, ImmutableArray<C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: ImmutableArray<A>) => readonly [ImmutableArray<B>, ImmutableArray<C>];
 /**
- * @tsplus fluent fncts.ImmutableArray prepend
+ * @tsplus pipeable fncts.ImmutableArray prepend
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function prepend_<A, B>(self: ImmutableArray<A>, head: B): ImmutableArray<A | B>;
+export declare function prepend<B>(head: B): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B | A>;
 /**
- * @tsplus fluent fncts.ImmutableArray prependAll
- * @tsplus fluent fncts.MutableArray prependAll
+ * @tsplus pipeable fncts.ImmutableArray prependAll
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function prependAll_<A>(self: ImmutableArray<A>, a: A): ImmutableArray<A>;
+export declare function prependAll<A>(a: A): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray reverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -437,94 +432,95 @@ export declare function reverse<A>(self: ImmutableArray<A>): ImmutableArray<A>;
  */
 export declare function rights<E, A>(self: ImmutableArray<Either<E, A>>): ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray rotate
+ * @tsplus pipeable fncts.ImmutableArray rotate
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function rotate_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+export declare function rotate(n: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray scanLeft
+ * @tsplus pipeable fncts.ImmutableArray scanLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function scanLeft_<A, B>(self: ImmutableArray<A>, b: B, f: (b: B, a: A) => B): ImmutableArray<B>;
+export declare function scanLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray scanRight
+ * @tsplus pipeable fncts.ImmutableArray scanRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function scanRight_<A, B>(self: ImmutableArray<A>, b: B, f: (a: A, b: B) => B): ImmutableArray<B>;
+export declare function scanRight<A, B>(b: B, f: (a: A, b: B) => B): (self: ImmutableArray<A>) => ImmutableArray<B>;
 /**
- * @tsplus fluent fncts.ImmutableArray sort
+ * @tsplus pipeable fncts.ImmutableArray sort
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function sort<A>(self: ImmutableArray<A>, /** @tsplus auto */ O: P.Ord<A>): ImmutableArray<A>;
+export declare function sort<A>(/** @tsplus auto */ O: P.Ord<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray sortBy
+ * @tsplus pipeable fncts.ImmutableArray sortBy
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function sortBy<A>(self: ImmutableArray<A>, Os: ImmutableArray<P.Ord<A>>): ImmutableArray<A>;
+export declare function sortBy<A>(Os: ImmutableArray<P.Ord<A>>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray spanLeft
+ * @tsplus pipeable fncts.ImmutableArray spanLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function spanLeft_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<B>, ImmutableArray<A>];
-export declare function spanLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function spanLeft<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => readonly [ImmutableArray<B>, ImmutableArray<A>];
+export declare function spanLeft<A>(p: Predicate<A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
 /**
- * @tsplus fluent fncts.ImmutableArray spanRight
+ * @tsplus pipeable fncts.ImmutableArray spanRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function spanRight_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): readonly [ImmutableArray<A>, ImmutableArray<B>];
-export declare function spanRight_<A>(self: ImmutableArray<A>, p: Predicate<A>): readonly [ImmutableArray<A>, ImmutableArray<A>];
+export declare function spanRight<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<B>];
+export declare function spanRight<A>(p: Predicate<A>): (self: ImmutableArray<A>) => readonly [ImmutableArray<A>, ImmutableArray<A>];
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexLeft
+ * @tsplus pipeable fncts.ImmutableArray spanIndexLeft
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function spanIndexLeft_<A>(self: ImmutableArray<A>, p: Predicate<A>): number;
+export declare function spanIndexLeft<A>(p: Predicate<A>): (self: ImmutableArray<A>) => number;
 /**
- * @tsplus fluent fncts.ImmutableArray spanIndexRight
+ * @tsplus pipeable fncts.ImmutableArray spanIndexRight
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function spanIndexRight_<A>(as: ImmutableArray<A>, predicate: Predicate<A>): number;
+export declare function spanIndexRight<A>(predicate: Predicate<A>): (as: ImmutableArray<A>) => number;
 /**
  * @tsplus getter fncts.ImmutableArray tail
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function tail<A>(self: ImmutableArray<A>): Maybe<ImmutableArray<A>>;
 /**
- * @tsplus fluent fncts.ImmutableArray take
+ * @tsplus pipeable fncts.ImmutableArray take
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function take_<A>(self: ImmutableArray<A>, n: number): ImmutableArray<A>;
+export declare function take(n: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray takeLast
+ * @tsplus pipeable fncts.ImmutableArray takeLast
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function takeLast_<A>(as: ImmutableArray<A>, n: number): ImmutableArray<A>;
+export declare function takeLast(n: number): <A>(as: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray takeWhile
+ * @tsplus pipeable fncts.ImmutableArray takeWhile
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function takeWhile_<A, B extends A>(self: ImmutableArray<A>, p: Refinement<A, B>): ImmutableArray<B>;
-export declare function takeWhile_<A>(self: ImmutableArray<A>, p: Predicate<A>): ImmutableArray<A>;
+export declare function takeWhile<A, B extends A>(p: Refinement<A, B>): (self: ImmutableArray<A>) => ImmutableArray<B>;
+export declare function takeWhile<A>(p: Predicate<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray traverseWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverseWithIndex_: <KF, QF, WF, XF, IF, SF, RF, EF, A>(ta: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<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, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _traverseWithIndex<A>(self: ImmutableArray<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, ImmutableArray<B>>;
 /**
  * @tsplus getter fncts.ImmutableArray traverse
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const traverse_: P.Traversable<ImmutableArrayF>["traverse"];
+export declare function _traverse<A>(self: ImmutableArray<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, ImmutableArray<B>>;
+export declare const traverseWithIndex: P.TraversableWithIndex<ImmutableArrayF>["traverseWithIndex"];
+export declare const traverse: P.Traversable<ImmutableArrayF>["traverse"];
 /**
- * @tsplus fluent fncts.ImmutableArray union
+ * @tsplus pipeable fncts.ImmutableArray union
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function union_<A>(self: ImmutableArray<A>, that: ImmutableArray<A>, 
-/** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
+export declare function union<A>(that: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray uniq
+ * @tsplus pipeable fncts.ImmutableArray uniq
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function uniq<A>(self: ImmutableArray<A>, /** @tsplus auto */ E: P.Eq<A>): ImmutableArray<A>;
+export declare function uniq<A>(/** @tsplus auto */ E: P.Eq<A>): (self: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray unprepend
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
@@ -541,62 +537,66 @@ export declare function unsafeGet<A>(self: ImmutableArray<A>, i: number): A | un
  */
 export declare function unsafeAsMutable<A>(self: ImmutableArray<A>): Array<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeDeleteAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeDeleteAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function unsafeDeleteAt_<A>(self: ImmutableArray<A>, i: number): ImmutableArray<A>;
+export declare function unsafeDeleteAt(i: number): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeInsertAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeInsertAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function unsafeInsertAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableNonEmptyArray<A>;
+export declare function unsafeInsertAt<A>(i: number, a: A): (as: ImmutableArray<A>) => ImmutableNonEmptyArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeModifyAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeModifyAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function unsafeModifyAt_<A>(as: ImmutableArray<A>, i: number, f: (a: A) => A): ImmutableArray<A>;
+export declare function unsafeModifyAt<A>(i: number, f: (a: A) => A): (as: ImmutableArray<A>) => ImmutableArray<A>;
 /**
- * @tsplus fluent fncts.ImmutableArray unsafeUpdateAt
+ * @tsplus pipeable fncts.ImmutableArray unsafeUpdateAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function unsafeUpdateAt_<A>(as: ImmutableArray<A>, i: number, a: A): ImmutableArray<A>;
+export declare function unsafeUpdateAt<A>(i: number, a: A): (as: ImmutableArray<A>) => ImmutableArray<A>;
 /**
  * @tsplus getter fncts.ImmutableArray unzip
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
 export declare function unzip<A, B>(self: ImmutableArray<readonly [A, B]>): readonly [ImmutableArray<A>, ImmutableArray<B>];
 /**
- * @tsplus fluent fncts.ImmutableArray updateAt
+ * @tsplus pipeable fncts.ImmutableArray updateAt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function updateAt_<A>(as: ImmutableArray<A>, i: number, a: A): Maybe<ImmutableArray<A>>;
+export declare function updateAt<A>(i: number, a: A): (as: ImmutableArray<A>) => Maybe<ImmutableArray<A>>;
 /**
  * @tsplus getter fncts.ImmutableArray wiltWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const wiltWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A, B, B2>(wa: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<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_1, B2_1>(f: (k: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/data/Either").Either<B_1, B2_1>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B_1>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2_1>]>;
+export declare function _wiltWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray wilt
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"];
+export declare function _wilt<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B, B2>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/data/Either").Either<B, B2>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, readonly [import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B2>]>;
 /**
  * @tsplus getter fncts.ImmutableArray witherWithIndex
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare const witherWithIndex: <KF, QF, WF, XF, IF, SF, RF, EF, A>(wa: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<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: (k: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, KG, QG, WG, XG, IG, SG, RG, EG, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare function _witherWithIndex<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (i: number, a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
 /**
  * @tsplus getter fncts.ImmutableArray wither
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
+export declare function _wither<A>(self: ImmutableArray<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("../../../data/Maybe").Maybe<B>>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E, import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<B>>;
+export declare const wiltWithIndex: P.WitherableWithIndex<ImmutableArrayF>["wiltWithIndex"];
+export declare const wilt: P.WitherableWithIndex<ImmutableArrayF>["wilt"];
+export declare const witherWithIndex: P.WitherableWithIndex<ImmutableArrayF>["witherWithIndex"];
 export declare const wither: P.Witherable<ImmutableArrayF>["wither"];
 /**
- * @tsplus fluent fncts.ImmutableArray zip
+ * @tsplus pipeable fncts.ImmutableArray zip
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function zip_<A, B>(self: ImmutableArray<A>, that: ImmutableArray<B>): ImmutableArray<readonly [A, B]>;
+export declare function zip<B>(that: ImmutableArray<B>): <A>(self: import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<A>) => import("@fncts/base/collection/immutable/ImmutableArray/definition").ImmutableArray<readonly [A, B]>;
 /**
- * @tsplus fluent fncts.ImmutableArray zipWith
+ * @tsplus pipeable fncts.ImmutableArray zipWith
  * @tsplus location "@fncts/base/collection/immutable/ImmutableArray/api"
  */
-export declare function zipWith_<A, B, C>(self: ImmutableArray<A>, fb: ImmutableArray<B>, f: (a: A, b: B) => C): ImmutableArray<C>;
+export declare function zipWith<A, B, C>(fb: ImmutableArray<B>, f: (a: A, b: B) => C): (self: ImmutableArray<A>) => ImmutableArray<C>;