@fncts/base 0.0.20 → 0.0.21

package/collection/immutable/Vector/internal.d.ts

@@ -106,10 +106,10 @@ export declare function incrementDepth(bits: number): number;
 export declare function decrementDepth(bits: number): number;
 /**
  * Appends the value to the Vector by _mutating_ the Vector and its content.
- * @tsplus fluent fncts.MutableVector push
+ * @tsplus pipeable fncts.MutableVector push
  * @tsplus location "@fncts/base/collection/immutable/Vector/internal"
  */
-export declare function push<A>(l: MutableVector<A>, value: A): MutableVector<A>;
+export declare function push<A>(value: A): (l: MutableVector<A>) => MutableVector<A>;
 /**
  * @internal
  */

package/collection/mutable/ListBuffer.d.ts

@@ -14,7 +14,7 @@ export declare class ListBuffer<A> implements Iterable<A> {
     unprepend(): A;
     get toList(): List<A>;
     insert(idx: number, elem: A): this;
-    foldl<B>(b: B, f: (b: B, a: A) => B): B;
+    foldLeft<B>(b: B, f: (b: B, a: A) => B): B;
     private getNext;
     private locate;
 }

package/control/Eval/api.d.ts

@@ -2,40 +2,40 @@ import { Eval } from "@fncts/base/control/Eval/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 import type { _A } from "@fncts/base/types";
 /**
- * @tsplus fluent fncts.control.Eval and
+ * @tsplus pipeable fncts.control.Eval and
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function and_(self: Eval<boolean>, that: Eval<boolean>): Eval<boolean>;
+export declare function and(that: Eval<boolean>): (self: Eval<boolean>) => Eval<boolean>;
 /**
- * @tsplus fluent fncts.control.Eval flatMap
+ * @tsplus pipeable fncts.control.Eval flatMap
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function flatMap_<A, B>(self: Eval<A>, f: (a: A) => Eval<B>): Eval<B>;
+export declare function flatMap<A, B>(f: (a: A) => Eval<B>): (self: Eval<A>) => Eval<B>;
 /**
  * @tsplus getter fncts.control.Eval flatten
  * @tsplus location "@fncts/base/control/Eval/api"
  */
 export declare function flatten<A>(self: Eval<Eval<A>>): Eval<A>;
 /**
- * @tsplus fluent fncts.control.Eval map
+ * @tsplus pipeable fncts.control.Eval map
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function map_<A, B>(self: Eval<A>, f: (a: A) => B): Eval<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Eval<A>) => Eval<B>;
 /**
- * @tsplus fluent fncts.control.Eval zipWith
+ * @tsplus pipeable fncts.control.Eval zipWith
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function zipWith_<A, B, C>(self: Eval<A>, fb: Eval<B>, f: (a: A, b: B) => C): Eval<C>;
+export declare function zipWith<A, B, C>(fb: Eval<B>, f: (a: A, b: B) => C): (self: Eval<A>) => Eval<C>;
 /**
- * @tsplus fluent fncts.control.Eval zip
+ * @tsplus pipeable fncts.control.Eval zip
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function zip_<A, B>(self: Eval<A>, fb: Eval<B>): Eval<Zipped.Make<A, B>>;
+export declare function zip<B>(fb: Eval<B>): <A>(self: import("@fncts/base/control/Eval/definition").Eval<A>) => import("@fncts/base/control/Eval/definition").Eval<import("../../data/Zipped.js").Zipped.Make<A, B>>;
 /**
- * @tsplus fluent fncts.control.Eval ap
+ * @tsplus pipeable fncts.control.Eval ap
  * @tsplus location "@fncts/base/control/Eval/api"
  */
-export declare function ap_<A, B>(self: Eval<(a: A) => B>, fa: Eval<A>): Eval<B>;
+export declare function ap<A>(fa: Eval<A>): <B>(self: import("@fncts/base/control/Eval/definition").Eval<(a: A) => B>) => import("@fncts/base/control/Eval/definition").Eval<B>;
 /**
  * @tsplus static fncts.control.EvalOps sequenceT
  * @tsplus location "@fncts/base/control/Eval/api"

package/control/Z/api.d.ts

@@ -13,63 +13,63 @@ import { Zipped } from "@fncts/base/data/Zipped";
  */
 export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Z<W, S1, S2, R, E, Either<E1, A>>): Z<W, S1, S2, R, E | E1, A>;
 /**
- * @tsplus fluent fncts.control.Z ap
+ * @tsplus pipeable fncts.control.Z ap
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function ap_<W, S, R, E, A, R1, E1, B>(self: Z<W, S, S, R, E, (a: A) => B>, fb: Z<W, S, S, R1, E1, A>): Z<W, S, S, R & R1, E | E1, B>;
+export declare function ap<W, S, A, R1, E1>(fb: Z<W, S, S, R1, E1, A>): <R, E, B>(self: import("./definition.js").Z<W, S, S, R, E, (a: A) => B>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
 /**
- * @tsplus fluent fncts.control.Z apFirst
+ * @tsplus pipeable fncts.control.Z apFirst
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function apFirst_<W, S, R, E, A, R1, E1, B>(fa: Z<W, S, S, R, E, A>, fb: Z<W, S, S, R1, E1, B>): Z<W, S, S, R & R1, E | E1, A>;
+export declare function apFirst<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, A>;
 /**
- * @tsplus fluent fncts.control.Z apSecond
+ * @tsplus pipeable fncts.control.Z apSecond
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function apSecond_<W, S, R, E, A, R1, E1, B>(fa: Z<W, S, S, R, E, A>, fb: Z<W, S, S, R1, E1, B>): Z<W, S, S, R & R1, E | E1, B>;
+export declare function apSecond<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
 /**
- * @tsplus fluent fncts.control.Z bimap
+ * @tsplus pipeable fncts.control.Z bimap
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function bimap_<W, S1, S2, R, E, A, G, B>(pab: Z<W, S1, S2, R, E, A>, f: (e: E) => G, g: (a: A) => B): Z<W, S1, S2, R, G, B>;
+export declare function bimap<E, A, G, B>(f: (e: E) => G, g: (a: A) => B): <W, S1, S2, R>(pab: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, G, B>;
 /**
  * Recovers from all errors.
- * @tsplus fluent fncts.control.Z catchAll
+ * @tsplus pipeable fncts.control.Z catchAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchAll_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): Z<W, S1, S3, R | R1, E1, A | B>;
+export declare function catchAll<W, S1, E, S3, R1, E1, B>(onFailure: (e: E) => Z<W, S1, S3, R1, E1, B>): <S2, R, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3, R1 | R, E1, B | A>;
 /**
- * @tsplus fluent fncts.control.Z catchJust
+ * @tsplus pipeable fncts.control.Z catchJust
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function catchJust_<W, S1, S2, R, E, A, S3, R1, E1, B>(fa: Z<W, S1, S2, R, E, A>, f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): Z<W, S1, S2 | S3, R | R1, E | E1, A | B>;
+export declare function catchJust<W, S1, E, S3, R1, E1, B>(f: (e: E) => Maybe<Z<W, S1, S3, R1, E1, B>>): <S2, R, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3 | S2, R1 | R, E | E1, B | A>;
 /**
- * @tsplus fluent fncts.control.Z flatMap
+ * @tsplus pipeable fncts.control.Z flatMap
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function flatMap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W, S1, S2, R, E, A>, f: (a: A) => Z<W1, S2, S3, R1, E1, B>): Z<W | W1, S1, S3, R1 & R, E1 | E, B>;
+export declare function flatMap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Z<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, B>;
 /**
- * @tsplus fluent fncts.control.Z contramapEnvironment
+ * @tsplus pipeable fncts.control.Z contramapEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function contramapEnvironment_<R0, W, S1, S2, R, E, A>(ma: Z<W, S1, S2, R, E, A>, f: (r0: Environment<R0>) => Environment<R>): Z<W, S1, S2, R0, E, A>;
+export declare function contramapEnvironment<R0, R>(f: (r0: Environment<R0>) => Environment<R>): <W, S1, S2, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R0, E, A>;
 /**
  * Transforms the initial state of this computation` with the specified
  * function.
- * @tsplus fluent fncts.control.Z contramapState
+ * @tsplus pipeable fncts.control.Z contramapState
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function contramapState_<S0, W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>, f: (s: S0) => S1): Z<W, S0, S2, R, E, A>;
+export declare function contramapState<S0, S1>(f: (s: S0) => S1): <W, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S0, S2, R, E, A>;
 /**
- * @tsplus fluent fncts.control.Z cross
+ * @tsplus pipeable fncts.control.Z cross
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function cross_<W, S, R, E, A, R1, E1, B>(fa: Z<W, S, S, R, E, A>, fb: Z<W, S, S, R1, E1, B>): Z<W, S, S, R & R1, E | E1, readonly [A, B]>;
+export declare function cross<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.control.Z crossWith
+ * @tsplus pipeable fncts.control.Z crossWith
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function crossWith_<W, S, R, E, A, R1, E1, B, C>(fa: Z<W, S, S, R, E, A>, fb: Z<W, S, S, R1, E1, B>, f: (a: A, b: B) => C): Z<W, S, S, R & R1, E | E1, C>;
+export declare function crossWith<W, S, A, R1, E1, B, C>(fb: Z<W, S, S, R1, E1, B>, f: (a: A, b: B) => C): <R, E>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, C>;
 /**
  * @tsplus static fncts.control.ZOps defer
  * @tsplus location "@fncts/base/control/Z/api"
@@ -161,67 +161,67 @@ export declare function haltNow(defect: unknown, __tsplusTrace?: string): Z<neve
  */
 export declare function listen<W, S1, S2, R, E, A>(wa: Z<W, S1, S2, R, E, A>): Z<W, S1, S2, R, E, readonly [A, Conc<W>]>;
 /**
- * @tsplus fluent fncts.control.Z listens
+ * @tsplus pipeable fncts.control.Z listens
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function listens_<W, S1, S2, R, E, A, B>(wa: Z<W, S1, S2, R, E, A>, f: (log: Conc<W>) => B): Z<W, S1, S2, R, E, readonly [A, B]>;
+export declare function listens<W, B>(f: (log: Conc<W>) => B): <S1, S2, R, E, A>(wa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.control.Z map
+ * @tsplus pipeable fncts.control.Z map
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function map_<W, S1, S2, R, E, A, B>(fa: Z<W, S1, S2, R, E, A>, f: (a: A) => B): Z<W, S1, S2, R, E, B>;
+export declare function map<A, B>(f: (a: A) => B): <W, S1, S2, R, E>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, B>;
 /**
- * @tsplus fluent fncts.control.Z mapError
+ * @tsplus pipeable fncts.control.Z mapError
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function mapError_<W, S1, S2, R, E, A, G>(pab: Z<W, S1, S2, R, E, A>, f: (e: E) => G): Z<W, S1, S2, R, G, A>;
+export declare function mapError<E, G>(f: (e: E) => G): <W, S1, S2, R, A>(pab: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, G, A>;
 /**
  * Modifies the current log with the specified function
- * @tsplus fluent fncts.control.Z mapLog
+ * @tsplus pipeable fncts.control.Z mapLog
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function mapLog_<W, S1, S2, R, E, A, W1>(wa: Z<W, S1, S2, R, E, A>, f: (ws: Conc<W>) => Conc<W1>): Z<W1, S1, S2, R, E, A>;
+export declare function mapLog<W, W1>(f: (ws: Conc<W>) => Conc<W1>): <S1, S2, R, E, A>(wa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1, S1, S2, R, E, A>;
 /**
  * Modifies the current state with the specified function
- * @tsplus fluent fncts.control.Z mapState
+ * @tsplus pipeable fncts.control.Z mapState
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function mapState_<W, S1, S2, R, E, A, S3>(ma: Z<W, S1, S2, R, E, A>, f: (s: S2) => S3): Z<W, S1, S3, R, E, A>;
+export declare function mapState<S2, S3>(f: (s: S2) => S3): <W, S1, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3, R, E, A>;
 /**
  * Folds over the failed or successful results of this computation to yield
  * a computation that does not fail, but succeeds with the value of the left
  * or right function passed to `match`.
- * @tsplus fluent fncts.control.Z match
+ * @tsplus pipeable fncts.control.Z match
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function match_<W, S1, S2, R, E, A, B, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => B, onSuccess: (a: A) => C): Z<W, S1, S2, R, never, B | C>;
+export declare function match<E, A, B, C>(onFailure: (e: E) => B, onSuccess: (a: A) => C): <W, S1, S2, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, never, B | C>;
 /**
  * Recovers from errors by accepting one computation to execute for the case
  * of an error, and one computation to execute for the case of success.
- * @tsplus fluent fncts.control.Z matchZ
+ * @tsplus pipeable fncts.control.Z matchZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
+export declare function matchZ<S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W2 | W, S1 & S5, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
 /**
- * @tsplus fluent fncts.control.Z matchCauseZ
+ * @tsplus pipeable fncts.control.Z matchCauseZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S0 & S1, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
+export declare function matchCauseZ<S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (a: A) => Z<W2, S2, S4, R2, E2, C>): <W, S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W2 | W, S0 & S1, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
 /**
- * @tsplus fluent fncts.control.Z matchLogZ
+ * @tsplus pipeable fncts.control.Z matchLogZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchLogZ_<W, S1, S5, S2, R, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W | W1 | W2, S1 & S5, S3 | S4, R | R1 | R2, E1 | E2, B | C>;
+export declare function matchLogZ<W, S5, S2, E, A, W1, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (ws: Conc<W>, e: E) => Z<W1, S5, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): <S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W | W1 | W2, S1 & S5, S3 | S4, R1 | R2 | R, E1 | E2, B | C>;
 /**
  * Recovers from errors by accepting one computation to execute for the case
  * of an error, and one computation to execute for the case of success. More powerful
  * than `matchCauseM` by providing the current state of the log as an argument in
  * each case
  * @note the log is cleared after being provided
- * @tsplus fluent fncts.control.Z matchLogCauseZ
+ * @tsplus pipeable fncts.control.Z matchLogCauseZ
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function matchLogCauseZ_<W, S1, S2, R, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(fa: Z<W, S1, S2, R, E, A>, onFailure: (ws: Conc<W>, e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): Z<W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
+export declare function matchLogCauseZ<W, S2, E, A, W1, S0, S3, R1, E1, B, W2, S4, R2, E2, C>(onFailure: (ws: Conc<W>, e: Cause<E>) => Z<W1, S0, S3, R1, E1, B>, onSuccess: (ws: Conc<W>, a: A) => Z<W2, S2, S4, R2, E2, C>): <S1, R>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W2, S0 & S1, S3 | S4, R & R1 & R2, E1 | E2, B | C>;
 /**
  * Constructs a computation from the specified modify function
  * @tsplus static fncts.control.ZOps modify
@@ -235,22 +235,22 @@ export declare function modify<S1, S2, A>(f: (s: S1) => readonly [A, S2]): Z<nev
  */
 export declare function modifyEither<S1, S2, E, A>(f: (s: S1) => Either<E, readonly [A, S2]>): Z<never, S1, S2, never, E, A>;
 /**
- * @tsplus fluent fncts.control.Z orElse
+ * @tsplus pipeable fncts.control.Z orElse
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElse_<W, S1, S2, R, E, A, W1, S3, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): Z<W | W1, S1, S2 | S3, R | R1, E | E1, A | A1>;
+export declare function orElse<S1, W1, S3, R1, E1, A1>(fb: Lazy<Z<W1, S1, S3, R1, E1, A1>>): <W, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3 | S2, R1 | R, E1 | E, A1 | A>;
 /**
  * Executes this computation and returns its value, if it succeeds, but
  * otherwise executes the specified computation.
- * @tsplus fluent fncts.control.Z orElseEither
+ * @tsplus pipeable fncts.control.Z orElseEither
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function orElseEither_<W, S1, S2, R, E, A, S3, S4, R1, E1, A1>(fa: Z<W, S1, S2, R, E, A>, that: Lazy<Z<W, S3, S4, R1, E1, A1>>): Z<W, S1 & S3, S2 | S4, R | R1, E1, Either<A, A1>>;
+export declare function orElseEither<W, S3, S4, R1, E1, A1>(that: Lazy<Z<W, S3, S4, R1, E1, A1>>): <S1, S2, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1 & S3, S4 | S2, R1 | R, E1, import("../../data/Either.js").Either<A, A1>>;
 /**
- * @tsplus fluent fncts.control.Z provideEnvironment
+ * @tsplus pipeable fncts.control.Z provideEnvironment
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function provideEnvironment_<W, S1, S2, R, E, A>(fa: Z<W, S1, S2, R, E, A>, r: Environment<R>): Z<W, S1, S2, never, E, A>;
+export declare function provideEnvironment<R>(r: Environment<R>): <W, S1, S2, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, never, E, A>;
 /**
  * Constructs a computation that sets the state to the specified value.
  * @tsplus static fncts.control.ZOps put
@@ -260,17 +260,17 @@ export declare function put<S>(s: S): Z<never, unknown, S, never, never, void>;
 /**
  * Repeats this computation the specified number of times (or until the first failure)
  * passing the updated state to each successive repetition.
- * @tsplus fluent fncts.control.Z repeatN
+ * @tsplus pipeable fncts.control.Z repeatN
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function repeatN_<W, S1, S2 extends S1, R, E, A>(ma: Z<W, S1, S2, R, E, A>, n: number): Z<W, S1, S2, R, E, A>;
+export declare function repeatN(n: number): <W, S1, S2 extends S1, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, A>;
 /**
  * Repeats this computation until its value satisfies the specified predicate
  * (or until the first failure) passing the updated state to each successive repetition.
- * @tsplus fluent fncts.control.Z repeatUntil
+ * @tsplus pipeable fncts.control.Z repeatUntil
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function repeatUntil_<W, S1, S2 extends S1, R, E, A>(ma: Z<W, S1, S2, R, E, A>, p: Predicate<A>): Z<W, S1, S2, R, E, A>;
+export declare function repeatUntil<A>(p: Predicate<A>): <W, S1, S2 extends S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S2, R, E, A>;
 /**
  * @tsplus static fncts.control.ZOps succeed
  * @tsplus location "@fncts/base/control/Z/api"
@@ -282,10 +282,10 @@ export declare function succeed<A, W = never, S1 = unknown, S2 = never>(effect:
  */
 export declare function succeedNow<A, W = never, S1 = unknown, S2 = never>(a: A, __tsplusTrace?: string): Z<W, S1, S2, never, never, A>;
 /**
- * @tsplus fluent fncts.control.Z tap
+ * @tsplus pipeable fncts.control.Z tap
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function tap_<W, S1, S2, R, E, A, W1, S3, R1, E1, B>(ma: Z<W, S1, S2, R, E, A>, f: (a: A) => Z<W1, S2, S3, R1, E1, B>): Z<W | W1, S1, S3, R1 & R, E1 | E, A>;
+export declare function tap<S2, A, W1, S3, R1, E1, B>(f: (a: A) => Z<W1, S2, S3, R1, E1, B>): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, A>;
 /**
  * @tsplus static fncts.control.ZOps tell
  * @tsplus location "@fncts/base/control/Z/api"
@@ -298,10 +298,10 @@ export declare function tell<W>(w: W): Z<W, unknown, never, never, never, void>;
 export declare function tellAll<W>(ws: Conc<W>): Z<W, unknown, never, never, never, void>;
 /**
  * Like `map`, but also allows the state to be modified.
- * @tsplus fluent fncts.control.Z transform
+ * @tsplus pipeable fncts.control.Z transform
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function transform_<W, S1, S2, R, E, A, S3, B>(ma: Z<W, S1, S2, R, E, A>, f: (s: S2, a: A) => readonly [B, S3]): Z<W, S1, S3, R, E, B>;
+export declare function transform<S2, A, S3, B>(f: (s: S2, a: A) => readonly [B, S3]): <W, S1, R, E>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W, S1, S3, R, E, B>;
 /**
  * @tsplus static fncts.control.ZOps unit
  * @tsplus location "@fncts/base/control/Z/api"
@@ -314,32 +314,32 @@ export declare const unit: Z<never, unknown, never, never, never, void>;
  */
 export declare function update<S1, S2>(f: (s: S1) => S2): Z<never, S1, S2, never, never, void>;
 /**
- * @tsplus fluent fncts.control.Z write
+ * @tsplus pipeable fncts.control.Z write
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function write_<W, S1, S2, R, E, A, W1>(ma: Z<W, S1, S2, R, E, A>, w: W1): Z<W | W1, S1, S2, R, E, A>;
+export declare function write<W1>(w: W1): <W, S1, S2, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S2, R, E, A>;
 /**
- * @tsplus fluent fncts.control.Z writeAll
+ * @tsplus pipeable fncts.control.Z writeAll
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function writeAll_<W, S1, S2, R, E, A, W1>(ma: Z<W, S1, S2, R, E, A>, log: Conc<W1>): Z<W | W1, S1, S2, R, E, A>;
+export declare function writeAll<W1>(log: Conc<W1>): <W, S1, S2, R, E, A>(ma: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S2, R, E, A>;
 /**
- * @tsplus fluent fncts.control.Z zip
+ * @tsplus pipeable fncts.control.Z zip
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function zip_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, Q, D, B>): Z<W | W1, S1, S3, Q & R, D | E, Zipped.Make<A, B>>;
+export declare function zip<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, import("../../data/Zipped.js").Zipped.Make<A, B>>;
 /**
- * @tsplus fluent fncts.control.Z zipFirst
+ * @tsplus pipeable fncts.control.Z zipFirst
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function zipFirst_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, Q, D, B>): Z<W | W1, S1, S3, Q & R, D | E, A>;
+export declare function zipFirst<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, A>;
 /**
- * @tsplus fluent fncts.control.Z zipSecond
+ * @tsplus pipeable fncts.control.Z zipSecond
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function zipSecond_<W, S1, S2, R, E, A, W1, S3, Q, D, B>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, Q, D, B>): Z<W | W1, S1, S3, Q & R, D | E, B>;
+export declare function zipSecond<S2, W1, S3, Q, D, B>(fb: Z<W1, S2, S3, Q, D, B>): <W, S1, R, E, A>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, Q & R, D | E, B>;
 /**
- * @tsplus fluent fncts.control.Z zipWith
+ * @tsplus pipeable fncts.control.Z zipWith
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function zipWith_<W, S1, S2, R, E, A, W1, S3, R1, E1, B, C>(fa: Z<W, S1, S2, R, E, A>, fb: Z<W1, S2, S3, R1, E1, B>, f: (a: A, b: B) => C): Z<W | W1, S1, S3, R1 & R, E1 | E, C>;
+export declare function zipWith<S2, A, W1, S3, R1, E1, B, C>(fb: Z<W1, S2, S3, R1, E1, B>, f: (a: A, b: B) => C): <W, S1, R, E>(fa: import("./definition.js").Z<W, S1, S2, R, E, A>) => import("./definition.js").Z<W1 | W, S1, S3, R1 & R, E1 | E, C>;

package/control/Z/runtime.d.ts

@@ -6,17 +6,17 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 /**
  * Runs this computation with the specified initial state, returning either a
  * failure or the updated state and the result
- * @tsplus fluent fncts.control.Z unsafeRunAll
+ * @tsplus pipeable fncts.control.Z unsafeRunAll
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunAll_<W, S1, S2, E, A>(ma: Z<W, S1, S2, never, E, A>, s: S1): readonly [Conc<W>, Exit<E, readonly [S2, A]>];
+export declare function unsafeRunAll<S1>(s: S1): <W, S2, E, A>(ma: import("./definition.js").Z<W, S1, S2, never, E, A>) => readonly [import("../../collection/immutable/Conc.js").Conc<W>, import("../../data/Exit.js").Exit<E, readonly [S2, A]>];
 /**
  * Runs this computation with the specified initial state, returning both
  * the updated state and the result.
- * @tsplus fluent fncts.control.Z unsafeRun
+ * @tsplus pipeable fncts.control.Z unsafeRun
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): readonly [S2, A];
+export declare function unsafeRun<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<W, S1, S2, never, never, A>) => readonly [S2, A];
 /**
  * Runs this computation, returning the result.
  * @tsplus getter fncts.control.Z unsafeRunResult
@@ -25,24 +25,24 @@ export declare function unsafeRun_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never,
 export declare function unsafeRunResult<W, A>(ma: Z<W, unknown, unknown, never, never, A>): A;
 /**
  * Runs this computation with the given environment, returning the result.
- * @tsplus fluent fncts.control.Z unsafeRunReader
+ * @tsplus pipeable fncts.control.Z unsafeRunReader
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunReader_<W, R, A>(ma: Z<W, unknown, never, R, never, A>, r: Environment<R>): A;
+export declare function unsafeRunReader<R>(r: Environment<R>): <W, A>(ma: import("./definition.js").Z<W, unknown, never, R, never, A>) => A;
 /**
  * Runs this computation with the specified initial state, returning the
  * updated state and discarding the result.
- * @tsplus fluent fncts.control.Z unsafeRunState
+ * @tsplus pipeable fncts.control.Z unsafeRunState
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunState_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): S2;
+export declare function unsafeRunState<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<W, S1, S2, never, never, A>) => S2;
 /**
  * Runs this computation with the specified initial state, returning the
  * result and discarding the updated state.
- * @tsplus fluent fncts.control.Z unsafeRunStateResult
+ * @tsplus pipeable fncts.control.Z unsafeRunStateResult
  * @tsplus location "@fncts/base/control/Z/runtime"
  */
-export declare function unsafeRunStateResult_<W, S1, S2, A>(ma: Z<W, S1, S2, never, never, A>, s: S1): A;
+export declare function unsafeRunStateResult<S1>(s: S1): <W, S2, A>(ma: import("./definition.js").Z<W, S1, S2, never, never, A>) => A;
 /**
  * Runs this computation returning either the result or error
  * @tsplus getter fncts.control.Z unsafeRunExit

package/data/Branded/derivations.d.ts

@@ -1,5 +1,5 @@
 import { Guard } from "@fncts/base/typeclass/Guard";
-import type { Validation, Brand } from "@fncts/base/data/Branded/definition";
+import type { Brand, Validation } from "@fncts/base/data/Branded/definition";
 import type { Check } from "@fncts/typelevel/Check";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
@@ -19,6 +19,6 @@ export declare function deriveGuard<A extends Brand.Valid<any, any>>(...[base, b
 export declare function deriveDecoder<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
     base: Decoder<Brand.Unbranded<A>>,
     brands: {
-        [K in (keyof A[Brand.valid]) & string]: Validation<A[Brand.valid][K], K>;
+        [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
     }
 ] : never): Decoder<A>;

package/data/Cause/api/fold.d.ts

@@ -5,10 +5,10 @@ import { Cause } from "@fncts/base/data/Cause/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 /**
  * Folds over a cause
- * @tsplus fluent fncts.Cause fold
+ * @tsplus pipeable fncts.Cause fold
  * @tsplus location "@fncts/base/data/Cause/api/fold"
  */
-export declare function fold_<E, Z>(self: Cause<E>, cases: {
+export declare function fold<E, Z>(cases: {
     Empty: () => Z;
     Fail: (e: E, trace: Trace) => Z;
     Halt: (t: unknown, trace: Trace) => Z;
@@ -16,4 +16,4 @@ export declare function fold_<E, Z>(self: Cause<E>, cases: {
     Then: (l: Z, r: Z) => Z;
     Both: (l: Z, r: Z) => Z;
     Stackless: (z: Z, stackless: boolean) => Z;
-}): Z;
+}): (self: Cause<E>) => Z;

package/data/Cause/api.d.ts

@@ -9,10 +9,10 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
 /**
- * @tsplus fluent fncts.Cause as
+ * @tsplus pipeable fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function as_<A, B>(self: Cause<A>, b: Lazy<B>): Cause<B>;
+export declare function as_<B>(b: Lazy<B>): <A>(self: Cause<A>) => Cause<B>;
 /**
  * Constructs a `Cause` from two `Cause`s, representing parallel failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned
@@ -23,16 +23,16 @@ export declare function as_<A, B>(self: Cause<A>, b: Lazy<B>): Cause<B>;
 export declare function both<E, E1>(left: Cause<E>, right: Cause<E1>): Cause<E | E1>;
 /**
  * Composes computations in sequence, using the return value of one computation as input for the next
- * @tsplus fluent fncts.Cause flatMap
+ * @tsplus pipeable fncts.Cause flatMap
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function flatMap_<E, D>(self: Cause<E>, f: (e: E) => Cause<D>): Cause<D>;
+export declare function flatMap<E, D>(f: (e: E) => Cause<D>): (self: Cause<E>) => Cause<D>;
 /**
  * Determines whether a `Cause` contains or is equal to the specified cause.
- * @tsplus fluent fncts.Cause contains
+ * @tsplus pipeable fncts.Cause contains
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function contains_<E, E1 extends E = E>(self: Cause<E>, that: Cause<E1>): boolean;
+export declare function contains<E, E1 extends E = E>(that: Cause<E1>): (self: Cause<E>) => boolean;
 /**
  * Extracts a list of non-recoverable errors from the `Cause`.
  * @tsplus getter fncts.Cause defects
@@ -98,16 +98,16 @@ export declare function failureMaybe<E>(self: Cause<E>): Maybe<E>;
  * Remove all `Halt` causes that the specified partial function is defined at,
  * returning `Just` with the remaining causes or `Nothing` if there are no
  * remaining causes.
- * @tsplus fluent fncts.Cause filterDefects
+ * @tsplus pipeable fncts.Cause filterDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function filterDefects_<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<Cause<E>>;
+export declare function filterDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
 /**
  * Finds the first result matching `f`
- * @tsplus fluent fncts.Cause find
+ * @tsplus pipeable fncts.Cause find
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function find_<E, A>(self: Cause<E>, f: (cause: Cause<E>) => Maybe<A>): Maybe<A>;
+export declare function find<E, A>(f: (cause: Cause<E>) => Maybe<A>): (self: Cause<E>) => Maybe<A>;
 /**
  * @tsplus getter fncts.Cause flatten
  * @tsplus location "@fncts/base/data/Cause/api"
@@ -129,10 +129,10 @@ export declare function flipCauseEither<E, A>(self: Cause<Either<E, A>>): Either
 export declare function flipCauseOption<E>(self: Cause<Maybe<E>>): Maybe<Cause<E>>;
 /**
  * Accumulates a state over a `Cause`
- * @tsplus fluent fncts.Cause foldLeft
+ * @tsplus pipeable fncts.Cause foldLeft
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function foldLeft_<A, B>(self: Cause<A>, b: B, f: (b: B, cause: Cause<A>) => Maybe<B>): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, cause: Cause<A>) => Maybe<B>): (self: Cause<A>) => B;
 /**
  * Constructs a `Cause` from a single `unknown`, representing an untyped failure
  * @tsplus static fncts.CauseOps halt
@@ -234,15 +234,15 @@ export declare function interruptedOnly<E>(self: Cause<E>): boolean;
  */
 export declare function keepDefects<E>(self: Cause<E>): Maybe<Cause<never>>;
 /**
- * @tsplus fluent fncts.Cause map
+ * @tsplus pipeable fncts.Cause map
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function map_<A, B>(self: Cause<A>, f: (e: A) => B): Cause<B>;
+export declare function map<A, B>(f: (e: A) => B): (self: Cause<A>) => Cause<B>;
 /**
- * @tsplus fluent fncts.Cause mapTrace
+ * @tsplus pipeable fncts.Cause mapTrace
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function mapTrace_<E>(self: Cause<E>, f: (trace: Trace) => Trace): Cause<E>;
+export declare function mapTrace(f: (trace: Trace) => Trace): <E>(self: Cause<E>) => Cause<E>;
 /**
  * @tsplus static fncts.CauseOps stackless
  * @tsplus static fncts.Cause.StacklessOps __call
@@ -259,10 +259,10 @@ export declare function stripFailures<A>(self: Cause<A>): Cause<never>;
  * Remove all `Halt` causes that the specified partial function is defined at,
  * returning `Just` with the remaining causes or `Nothing` if there are no
  * remaining causes.
- * @tsplus fluent fncts.Cause stripSomeDefects
+ * @tsplus pipeable fncts.Cause stripSomeDefects
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function stripSomeDefects<E>(self: Cause<E>, p: Predicate<unknown>): Maybe<Cause<E>>;
+export declare function stripSomeDefects(p: Predicate<unknown>): <E>(self: Cause<E>) => import("../Maybe.js").Maybe<Cause<E>>;
 /**
  * Converts the specified `Cause<Either<E, A>>` to an `Either<Cause<E>, A>`.
  * @tsplus getter fncts.Cause sequenceCauseEither
@@ -278,10 +278,10 @@ export declare function sequenceCauseMaybe<E>(self: Cause<Maybe<E>>): Maybe<Caus
 /**
  * Squashes a `Cause` down to a single `Error`, chosen to be the
  * "most important" `Error`.
- * @tsplus fluent fncts.Cause squashWith
+ * @tsplus pipeable fncts.Cause squashWith
  * @tsplus location "@fncts/base/data/Cause/api"
  */
-export declare function squashWith_<E>(self: Cause<E>, f: (e: E) => unknown): unknown;
+export declare function squashWith<E>(f: (e: E) => unknown): (self: Cause<E>) => unknown;
 /**
  * Constructs a `Cause` from two `Cause`s, representing sequential failures.
  * @note If one of the `Cause`s is `Empty`, the non-empty `Cause` is returned