@fncts/base 0.0.19 → 0.0.21

package/data/Exit/api.d.ts

@@ -3,40 +3,40 @@ import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Cause } from "@fncts/base/data/Cause/definition";
 /**
- * @tsplus fluent fncts.Exit ap
+ * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function ap_<E, A, G, B>(fab: Exit<G, (a: A) => B>, fa: Exit<E, A>): Exit<E | G, B>;
+export declare function ap<E, A>(fa: Exit<E, A>): <G, B>(fab: import("./definition.js").Exit<G, (a: A) => B>) => import("./definition.js").Exit<E | G, B>;
 /**
- * @tsplus fluent fncts.Exit apFirst
+ * @tsplus pipeable fncts.Exit apFirst
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirst_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A>;
+export declare function apFirst<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus fluent fncts.Exit apSecond
+ * @tsplus pipeable fncts.Exit apSecond
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecond_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B>;
+export declare function apSecond<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
- * @tsplus fluent fncts.Exit apFirstC
+ * @tsplus pipeable fncts.Exit apFirstC
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirstC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, A>;
+export declare function apFirstC<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus fluent fncts.Exit apSecondC
+ * @tsplus pipeable fncts.Exit apSecondC
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecondC_<E, G, A, B>(fa: Exit<E, A>, fb: Exit<G, B>): Exit<E | G, B>;
+export declare function apSecondC<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
- * @tsplus fluent fncts.Exit flatMap
+ * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function flatMap_<E, A, G, B>(ma: Exit<E, A>, f: (a: A) => Exit<G, B>): Exit<E | G, B>;
+export declare function flatMap<A, G, B>(f: (a: A) => Exit<G, B>): <E>(ma: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
- * @tsplus fluent fncts.Exit bimap
+ * @tsplus pipeable fncts.Exit bimap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function bimap_<E1, A, E2, B>(self: Exit<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Exit<E2, B>;
+export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (self: Exit<E1, A>) => Exit<E2, B>;
 /**
  * @tsplus static fncts.ExitOps collectAll
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -53,47 +53,47 @@ export declare function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E
  */
 export declare function flatten<E, G, A>(mma: Exit<E, Exit<G, A>>): Exit<E | G, A>;
 /**
- * @tsplus fluent fncts.Exit map
+ * @tsplus pipeable fncts.Exit map
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function map_<E, A, B>(fa: Exit<E, A>, f: (a: A) => B): Exit<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<E, B>;
 /**
- * @tsplus fluent fncts.Exit mapError
+ * @tsplus pipeable fncts.Exit mapError
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapError_<E1, A, E2>(self: Exit<E1, A>, f: (e: E1) => E2): Exit<E2, A>;
+export declare function mapError<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
 /**
- * @tsplus fluent fncts.Exit mapErrorCause
+ * @tsplus pipeable fncts.Exit mapErrorCause
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function mapErrorCause_<E1, A, E2>(self: Exit<E1, A>, f: (e: Cause<E1>) => Cause<E2>): Exit<E2, A>;
+export declare function mapErrorCause<E1, E2>(f: (e: Cause<E1>) => Cause<E2>): <A>(self: import("./definition.js").Exit<E1, A>) => import("./definition.js").Exit<E2, A>;
 /**
- * @tsplus fluent fncts.Exit match
+ * @tsplus pipeable fncts.Exit match
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function match_<E, A, B, C>(exit: Exit<E, A>, onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): B | C;
+export declare function match<E, A, B, C>(onFailure: (e: Cause<E>) => B, onSuccess: (a: A) => C): (exit: Exit<E, A>) => B | C;
 /**
- * @tsplus fluent fncts.Exit zipWith
+ * @tsplus pipeable fncts.Exit zipWith
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWith_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C>;
+export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
 /**
- * @tsplus fluent fncts.Exit zip
+ * @tsplus pipeable fncts.Exit zip
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zip<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]>;
+export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.Exit zipWithC
+ * @tsplus pipeable fncts.Exit zipWithC
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithC_<EA, A, EB, B, C>(fa: Exit<EA, A>, fb: Exit<EB, B>, f: (a: A, b: B) => C): Exit<EA | EB, C>;
+export declare function zipWithC<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
 /**
- * @tsplus fluent fncts.Exit zipC
+ * @tsplus pipeable fncts.Exit zipC
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipC<EA, A, EB, B>(self: Exit<EA, A>, that: Exit<EB, B>): Exit<EA | EB, readonly [A, B]>;
+export declare function zipC<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.Exit zipWithCause
+ * @tsplus pipeable fncts.Exit zipWithCause
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithCause_<E, A, G, B, C>(fa: Exit<E, A>, fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): Exit<E | G, C>;
+export declare function zipWithCause<E, A, G, B, C>(fb: Exit<G, B>, f: (a: A, b: B) => C, g: (ea: Cause<E>, eb: Cause<G>) => Cause<E | G>): (fa: Exit<E, A>) => Exit<E | G, C>;

package/data/Exit/constructors.d.ts

@@ -22,7 +22,7 @@ export declare function fromEither<E = never, A = never>(e: Either<E, A>): Exit<
  * @tsplus static fncts.ExitOps fromMaybe
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function fromMaybe_<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A>;
+export declare function fromMaybe<E, A>(fa: Maybe<A>, onNothing: () => E): Exit<E, A>;
 /**
  * @tsplus static fncts.ExitOps failCause
  * @tsplus location "@fncts/base/data/Exit/constructors"
@@ -32,7 +32,7 @@ export declare function failCause<E = never, A = never>(cause: Cause<E>): Exit<E
  * @tsplus static fncts.ExitOps interrupt
  * @tsplus location "@fncts/base/data/Exit/constructors"
  */
-export declare function interrupt(id: FiberId): import("./definition.js").Exit<never, never>;
+export declare function interrupt(id: FiberId): Exit<never, never>;
 /**
  * @tsplus static fncts.ExitOps succeed
  * @tsplus location "@fncts/base/data/Exit/constructors"

package/data/FiberId/api.d.ts

@@ -1,10 +1,10 @@
 import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
 /**
- * @tsplus fluent fncts.FiberId combine
+ * @tsplus pipeable fncts.FiberId combine
  * @tsplus location "@fncts/base/data/FiberId/api"
  */
-export declare function combine_(id0: FiberId, id1: FiberId): FiberId;
+export declare function combine(id1: FiberId): (id0: FiberId) => FiberId;
 /**
  * @tsplus getter fncts.FiberId ids
  * @tsplus location "@fncts/base/data/FiberId/api"

package/data/Identity/api.d.ts

@@ -1,15 +1,15 @@
 import { Identity } from "@fncts/base/data/Identity/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 /**
- * @tsplus fluent fncts.Identity ap
+ * @tsplus pipeable fncts.Identity ap
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function ap_<A, B>(fab: Identity<(a: A) => B>, fa: Identity<A>): Identity<B>;
+export declare function ap<A>(fa: Identity<A>): <B>(fab: import("./definition").Identity<(a: A) => B>) => import("./definition").Identity<B>;
 /**
- * @tsplus fluent fncts.Identity map
+ * @tsplus pipeable fncts.Identity map
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B>;
+export declare function map<A, B>(f: (a: A) => B): (fa: Identity<A>) => Identity<B>;
 /**
  * @tsplus static fncts.IdentityOps pure
  * @tsplus static fncts.IdentityOps __call
@@ -17,15 +17,15 @@ export declare function map_<A, B>(fa: Identity<A>, f: (a: A) => B): Identity<B>
  */
 export declare function pure<A>(a: A): Identity<A>;
 /**
- * @tsplus fluent fncts.Identity zipWith
+ * @tsplus pipeable fncts.Identity zipWith
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C>;
+export declare function zipWith<A, B, C>(fb: Identity<B>, f: (a: A, b: B) => C): (fa: Identity<A>) => Identity<C>;
 /**
- * @tsplus fluent fncts.Identity zip
+ * @tsplus pipeable fncts.Identity zip
  * @tsplus location "@fncts/base/data/Identity/api"
  */
-export declare function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<Zipped.Make<A, B>>;
+export declare function zip<B>(fb: Identity<B>): <A>(fa: import("./definition").Identity<A>) => import("./definition").Identity<import("../Zipped").Zipped.Make<A, B>>;
 /**
  * @tsplus getter fncts.Identity getIdentity
  * @tsplus macro identity

package/data/Interval.d.ts

@@ -29,31 +29,31 @@ export declare const empty: Interval;
  */
 export declare function isEmpty(self: Interval): boolean;
 /**
- * @tsplus fluent fncts.io.Schedule.Interval intersect
+ * @tsplus pipeable fncts.io.Schedule.Interval intersect
  * @tsplus location "@fncts/base/data/Interval"
  */
-export declare function intersect_(self: Interval, that: Interval): Interval;
+export declare function intersect_(that: Interval): (self: Interval) => Interval;
 /**
- * @tsplus fluent fncts.io.Schedule.Interval lt
- * @tsplus operator fncts.io.Schedule.Interval <
+ * @tsplus pipeable fncts.io.Schedule.Interval lt
+ * @tsplus pipeable-operator fncts.io.Schedule.Interval <
  * @tsplus location "@fncts/base/data/Interval"
  */
-export declare function lt_(self: Interval, that: Interval): boolean;
+export declare function lt(that: Interval): (self: Interval) => boolean;
 /**
  * @tsplus static fncts.io.Schedule.IntervalOps __call
  * @tsplus location "@fncts/base/data/Interval"
  */
 export declare function makeInterval(start: number, end: number): Interval;
 /**
- * @tsplus fluent fncts.io.Schedule.Interval max
+ * @tsplus pipeable fncts.io.Schedule.Interval max
  * @tsplus location "@fncts/base/data/Interval"
  */
-export declare function max_(self: Interval, that: Interval): Interval;
+export declare function max(that: Interval): (self: Interval) => Interval;
 /**
- * @tsplus fluent fncts.io.Schedule.Interval min
+ * @tsplus pipeable fncts.io.Schedule.Interval min
  * @tsplus location "@fncts/base/data/Interval"
  */
-export declare function min_(self: Interval, that: Interval): Interval;
+export declare function min(that: Interval): (self: Interval) => Interval;
 /**
  * @tsplus getter fncts.io.Schedule.Interval isNonEmpty
  * @tsplus location "@fncts/base/data/Interval"
@@ -65,7 +65,7 @@ export declare function isNonEmpty(self: Interval): boolean;
  */
 export declare function size(self: Interval): number;
 /**
- * @tsplus fluent fncts.io.Schedule.Interval union
+ * @tsplus pipeable fncts.io.Schedule.Interval union
  * @tsplus location "@fncts/base/data/Interval"
  */
-export declare function union_(self: Interval, that: Interval): Maybe<Interval>;
+export declare function union(that: Interval): (self: Interval) => Maybe<Interval>;

package/data/Intervals.d.ts

@@ -14,17 +14,17 @@ export declare class Intervals {
  */
 export declare function make(intervals: List<Interval>): Intervals;
 /**
- * @tsplus fluent fncts.Intervals union
- * @tsplus operator fncts.Intervals ||
+ * @tsplus pipeable fncts.Intervals union
+ * @tsplus pipeable-operator fncts.Intervals ||
  * @tsplus location "@fncts/base/data/Intervals"
  */
-export declare function union(self: Intervals, that: Intervals): Intervals;
+export declare function union(that: Intervals): (self: Intervals) => Intervals;
 /**
- * @tsplus fluent fncts.Intervals intersect
- * @tsplus operator fncts.Intervals &&
+ * @tsplus pipeable fncts.Intervals intersect
+ * @tsplus pipeable-operator fncts.Intervals &&
  * @tsplus location "@fncts/base/data/Intervals"
  */
-export declare function intersect(self: Intervals, that: Intervals): Intervals;
+export declare function intersect(that: Intervals): (self: Intervals) => Intervals;
 /**
  * @tsplus getter fncts.Intervals start
  * @tsplus location "@fncts/base/data/Intervals"
@@ -36,16 +36,16 @@ export declare function start(self: Intervals): number;
  */
 export declare function end(self: Intervals): number;
 /**
- * @tsplus fluent fncts.Intervals lt
- * @tsplus operator fncts.Intervals <
+ * @tsplus pipeable fncts.Intervals lt
+ * @tsplus pipeable-operator fncts.Intervals <
  * @tsplus location "@fncts/base/data/Intervals"
  */
-export declare function lt(self: Intervals, that: Intervals): boolean;
+export declare function lt(that: Intervals): (self: Intervals) => boolean;
 /**
- * @tsplus fluent fncts.Intervals max
+ * @tsplus pipeable fncts.Intervals max
  * @tsplus location "@fncts/base/data/Intervals"
  */
-export declare function max(self: Intervals, that: Intervals): Intervals;
+export declare function max(that: Intervals): (self: Intervals) => Intervals;
 /**
  * @tsplus getter fncts.Intervals isNonEmpty
  * @tsplus location "@fncts/base/data/Intervals"

package/data/Maybe/api.d.ts

@@ -7,93 +7,92 @@ import { Zipped } from "@fncts/base/data/Zipped";
 import type { Eq, Monoid } from "@fncts/base/typeclass";
 import type { Nullable } from "@fncts/base/types";
 /**
- * @tsplus fluent fncts.Maybe ap
+ * @tsplus pipeable fncts.Maybe ap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function ap_<A, B>(self: Maybe<(a: A) => B>, fa: Maybe<A>): Maybe<B>;
+export declare function ap<A>(fa: Maybe<A>): <B>(self: import("./definition.js").Maybe<(a: A) => B>) => import("./definition.js").Maybe<B>;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just` and returns the result,
  * otherwise returns `Nothing`.
- * @tsplus fluent fncts.Maybe flatMap
+ * @tsplus pipeable fncts.Maybe flatMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function flatMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+export declare function flatMap<A, B>(f: (a: A) => Maybe<B>): (self: Maybe<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.Maybe elem
+ * @tsplus pipeable fncts.Maybe elem
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function elem_<A>(self: Maybe<A>, elem: A, E: Eq<A>): boolean;
+export declare function elem<A>(elem: A, /** @tsplus auto */ E: Eq<A>): (self: Maybe<A>) => boolean;
 /**
- * @constrained
- * @tsplus fluent fncts.Maybe exists
+ * @tsplus pipeable fncts.Maybe exists
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function exists_<A>(self: Maybe<A>, p: Predicate<A>): boolean;
+export declare function exists<A>(p: Predicate<A>): (self: Maybe<A>) => boolean;
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable fncts.Maybe filter
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function filter_<A, B>(self: Maybe<A>, p: Predicate<A>): Maybe<A>;
-export declare function filter_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): Maybe<B>;
+export declare function filter<A>(p: Predicate<A>): <B>(self: Maybe<A>) => Maybe<A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => Maybe<B>;
 /**
- * @tsplus fluent fncts.Maybe filter
+ * @tsplus pipeable fncts.Maybe filter
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function filterMap_<A, B>(self: Maybe<A>, f: (a: A) => Maybe<B>): Maybe<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Maybe<A>) => Maybe<B>;
 /**
  * @tsplus getter fncts.Maybe flatten
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
 export declare function flatten<A>(self: Maybe<Maybe<A>>): Maybe<A>;
 /**
- * @tsplus fluent fncts.Maybe partition
+ * @tsplus pipeable fncts.Maybe partition
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function partition_<A>(self: Maybe<A>, p: Predicate<A>): readonly [Maybe<A>, Maybe<A>];
-export declare function partition_<A, B extends A>(self: Maybe<A>, p: Refinement<A, B>): readonly [Maybe<A>, Maybe<B>];
+export declare function partition<A>(p: Predicate<A>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Maybe<A>) => readonly [Maybe<A>, Maybe<B>];
 /**
- * @tsplus fluent fncts.Maybe partitionMap
+ * @tsplus pipeable fncts.Maybe partitionMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function partitionMap_<A, B, C>(self: Maybe<A>, f: (a: A) => Either<B, C>): readonly [Maybe<B>, Maybe<C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Maybe<A>) => readonly [Maybe<B>, Maybe<C>];
 /**
- * @tsplus fluent fncts.Maybe foldLeft
+ * @tsplus pipeable fncts.Maybe foldLeft
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldLeft_<A, B>(self: Maybe<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: Maybe<A>) => B;
 /**
- * @tsplus fluent fncts.Maybe foldRight
+ * @tsplus pipeable fncts.Maybe foldRight
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldRight_<A, B>(self: Maybe<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: Maybe<A>) => B;
 /**
- * @tsplus fluent fncts.Maybe foldMap
+ * @tsplus pipeable fncts.Maybe foldMap
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function foldMap_<A, M>(self: Maybe<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: Maybe<A>) => M;
 /**
  * Extracts the value from `Maybe` if it exists, or returns the result of `orElse`.
- * @tsplus fluent fncts.Maybe getOrElse
+ * @tsplus pipeable fncts.Maybe getOrElse
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function getOrElse_<A, B>(self: Maybe<A>, orElse: Lazy<B>): A | B;
+export declare function getOrElse<B>(orElse: Lazy<B>): <A>(self: import("./definition.js").Maybe<A>) => B | A;
 /**
  * Applies `f` to the value contained in `Maybe` if it is `Just`, otherwise returns `Nothing`.
- * @tsplus fluent fncts.Maybe map
+ * @tsplus pipeable fncts.Maybe map
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function map_<A, B>(self: Maybe<A>, f: (a: A) => B): Maybe<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Maybe<A>) => Maybe<B>;
 /**
  * `chain` + `fromNullable`
- * @tsplus fluent fncts.Maybe mapNullable
+ * @tsplus pipeable fncts.Maybe mapNullable
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function mapNullable_<A, B>(self: Maybe<A>, f: (a: A) => Nullable<B>): Maybe<NonNullable<B>>;
+export declare function mapNullable<A, B>(f: (a: A) => Nullable<B>): (self: Maybe<A>) => Maybe<NonNullable<B>>;
 /**
- * @tsplus fluent fncts.Maybe orElse
+ * @tsplus pipeable fncts.Maybe orElse
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe<A | B>;
+export declare function orElse<B>(fb: Lazy<Maybe<B>>): <A>(self: import("./definition.js").Maybe<A>) => import("./definition.js").Maybe<B | A>;
 /**
  * Extracts the value from `Maybe` if it is `Just`, otherwise returns `undefined`
  * @tsplus getter fncts.Maybe value
@@ -101,12 +100,12 @@ export declare function orElse_<A, B>(self: Maybe<A>, fb: Lazy<Maybe<B>>): Maybe
  */
 export declare function toUndefined<A>(self: Maybe<A>): A | undefined;
 /**
- * @tsplus fluent fncts.Maybe zipWith
+ * @tsplus pipeable fncts.Maybe zipWith
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zipWith_<A, B, C>(self: Maybe<A>, fb: Maybe<B>, f: (a: A, b: B) => C): Maybe<C>;
+export declare function zipWith<A, B, C>(fb: Maybe<B>, f: (a: A, b: B) => C): (self: Maybe<A>) => Maybe<C>;
 /**
- * @tsplus fluent fncts.Maybe zip
+ * @tsplus pipeable fncts.Maybe zip
  * @tsplus location "@fncts/base/data/Maybe/api"
  */
-export declare function zip_<A, B>(self: Maybe<A>, that: Maybe<B>): Maybe<Zipped.Make<A, B>>;
+export declare function zip<B>(that: Maybe<B>): <A>(self: import("./definition.js").Maybe<A>) => import("./definition.js").Maybe<import("../Zipped.js").Zipped.Make<A, B>>;

package/data/Maybe/constructors.d.ts

@@ -28,8 +28,8 @@ export declare function fromNullableK<P extends ReadonlyArray<unknown>, A>(f: (.
  * @tsplus static fncts.MaybeOps fromPredicate
  * @tsplus location "@fncts/base/data/Maybe/constructors"
  */
-export declare function fromPredicate_<A>(a: A, p: Predicate<A>): Maybe<A>;
-export declare function fromPredicate_<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
+export declare function fromPredicate<A>(a: A, p: Predicate<A>): Maybe<A>;
+export declare function fromPredicate<A, B extends A>(a: A, p: Refinement<A, B>): Maybe<A>;
 /**
  * @tsplus static fncts.MaybeOps tryCatch
  * @tsplus location "@fncts/base/data/Maybe/constructors"

package/data/Maybe/definition.d.ts

@@ -44,9 +44,13 @@ export declare class Nothing extends Maybe<never> {
 /**
  * @tsplus unify fncts.Maybe
  */
-export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[X] extends [{
-    _A: () => infer A;
-}] ? A : never>;
+export declare function unifyMaybe<X extends Maybe<any>>(self: X): Maybe<[
+    X
+] extends [
+    {
+        _A: () => infer A;
+    }
+] ? A : never>;
 /**
  * @tsplus static fncts.MaybeOps isMaybe
  * @tsplus location "@fncts/base/data/Maybe/definition"

package/data/Maybe/destructors.d.ts

@@ -2,7 +2,7 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
  * Matches on each case of a `Maybe`, returning the result of `nothing` if the `Maybe`
  * is `Nothing`, or returning the result of `just` if it is `Just`
- * @tsplus fluent fncts.Maybe match
+ * @tsplus pipeable fncts.Maybe match
  * @tsplus location "@fncts/base/data/Maybe/destructors"
  */
-export declare function match_<A, B, C>(self: Maybe<A>, nothing: () => B, just: (a: A) => C): B | C;
+export declare function match<A, B, C>(nothing: () => B, just: (a: A) => C): (self: Maybe<A>) => B | C;

package/data/Predicate/api.d.ts

@@ -1,14 +1,14 @@
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 /**
- * @tsplus operator fncts.Predicate &&
+ * @tsplus pipeable-operator fncts.Predicate &&
  * @tsplus location "@fncts/base/data/Predicate/api"
  */
-export declare function and<A>(self: Predicate<A>, that: Predicate<A>): Predicate<A>;
+export declare function and<A>(that: Predicate<A>): (self: Predicate<A>) => Predicate<A>;
 /**
- * @tsplus fluent fncts.Predicate contramap
+ * @tsplus pipeable fncts.Predicate contramap
  * @tsplus location "@fncts/base/data/Predicate/api"
  */
-export declare function contramap<A, B>(self: Predicate<A>, f: (b: B) => A): Predicate<B>;
+export declare function contramap<A, B>(f: (b: B) => A): (self: Predicate<A>) => Predicate<B>;
 /**
  * @tsplus getter fncts.Predicate invert
  * @tsplus location "@fncts/base/data/Predicate/api"
@@ -18,4 +18,4 @@ export declare function invert<A>(self: Predicate<A>): Predicate<A>;
  * @tsplus operator fncts.Predicate ||
  * @tsplus location "@fncts/base/data/Predicate/api"
  */
-export declare function or<A extends B, B>(self: Predicate<A>, that: Predicate<B>): Predicate<A>;
+export declare function or<A extends B, B>(that: Predicate<B>): (self: Predicate<A>) => Predicate<A>;

package/data/Refinement/api.d.ts

@@ -1,23 +1,23 @@
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 /**
- * @tsplus fluent fncts.Refinement and
- * @tsplus operator fncts.Refinement &&
+ * @tsplus pipeable fncts.Refinement and
+ * @tsplus pipeable-operator fncts.Refinement &&
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
-export declare function and<A, B extends A, C extends B>(self: Refinement<A, B>, that: Refinement<B, C>): Refinement<A, C>;
-export declare function and<A, B extends A>(self: Refinement<A, B>, that: Predicate<B>): Refinement<A, B>;
+export declare function and<A, B extends A, C extends B>(that: Refinement<B, C>): (self: Refinement<A, B>) => Refinement<A, C>;
+export declare function and<A, B extends A>(that: Predicate<B>): (self: Refinement<A, B>) => Refinement<A, B>;
 /**
- * @tsplus fluent fncts.Refinement contramap
+ * @tsplus pipeable fncts.Refinement contramap
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
-export declare function contramap<A extends C, B extends A, C>(self: Refinement<A, B>, f: (c: C) => A): Refinement<C, B>;
+export declare function contramap<A extends C, C>(f: (c: C) => A): <B extends A>(self: import("./definition").Refinement<A, B>) => import("./definition").Refinement<C, B>;
 /**
- * @tsplus fluent fncts.Refinement or
- * @tsplus operator fncts.Refinement ||
+ * @tsplus pipeable fncts.Refinement or
+ * @tsplus pipeable-operator fncts.Refinement ||
  * @tsplus location "@fncts/base/data/Refinement/api"
  */
-export declare function or<A, B extends A, C extends A>(self: Refinement<A, B>, that: Refinement<A, C>): Refinement<A, B | C>;
+export declare function or<A, C extends A>(that: Refinement<A, C>): <B extends A>(self: import("./definition").Refinement<A, B>) => import("./definition").Refinement<A, C | B>;
 /**
  * @tsplus fluent fncts.Refinement invert
  * @tsplus location "@fncts/base/data/Refinement/api"

package/data/Struct/api.d.ts

@@ -14,47 +14,37 @@ export type EnsureLiteralTuple<A extends ReadonlyArray<unknown>> = unknown exten
  */
 export declare function makeStruct<A>(a: A): Struct<A>;
 /**
- * @tsplus fluent fncts.Struct set
+ * @tsplus pipeable fncts.Struct set
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function set_<A, N extends string, B>(self: Struct<A>, key: EnsureLiteral<N>, value: B): Struct<{
-    [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
-}>;
+export declare function set<N extends string, B>(key: EnsureLiteral<N>, value: B): <A>(self: Struct<A>) => Struct<{ [P in N | Exclude<keyof A, N>]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
 /**
- * @tsplus fluent fncts.Struct hmap
+ * @tsplus pipeable fncts.Struct hmap
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function hmap_<A extends {}, F extends {
+export declare function hmap<A extends {}, F extends {
     [N in keyof A]: (a: A[N]) => any;
-}>(self: Struct<A>, fs: F): Struct<{
-    readonly [K in keyof F]: ReturnType<F[K]>;
-}>;
+}>(fs: F): (self: Struct<A>) => Struct<{ readonly [K in keyof F]: ReturnType<F[K]>; }>;
 /**
- * @tsplus fluent fncts.Struct modify
+ * @tsplus pipeable fncts.Struct modify
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function modify_<A, N extends keyof A, B>(self: Struct<A>, key: N, f: (a: A[N]) => B): Struct<{
-    readonly [P in Exclude<keyof A, N> | N]: P extends Exclude<keyof A, N> ? A[P] : B;
-}>;
+export declare function modify<A, N extends keyof A, B>(key: N, f: (a: A[N]) => B): (self: Struct<A>) => Struct<{ readonly [P in N | Exclude<keyof A, N>]: P extends Exclude<keyof A, N> ? A[P] : B; }>;
 /**
- * @tsplus fluent fncts.Struct pick
+ * @tsplus pipeable fncts.Struct pick
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function pick_<A, N extends ReadonlyArray<keyof A>>(self: Struct<A>, keys: [...N]): Struct<{
-    readonly [P in N[number]]: A[P];
-}>;
+export declare function pick<A, N extends ReadonlyArray<keyof A>>(keys: [...N]): (self: Struct<A>) => Struct<{ readonly [P in N[number]]: A[P]; }>;
 /**
- * @tsplus fluent fncts.Struct omit
+ * @tsplus pipeable fncts.Struct omit
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function omit_<A extends {}, N extends ReadonlyArray<keyof A>>(self: Struct<A>, keys: [...N]): Struct<{
-    readonly [P in Exclude<keyof A, N[number]>]: A[P];
-}>;
+export declare function omit<A extends {}, N extends ReadonlyArray<keyof A>>(keys: [...N]): (self: Struct<A>) => Struct<{ readonly [P in Exclude<keyof A, N[number]>]: A[P]; }>;
 /**
- * @tsplus fluent fncts.Struct map
+ * @tsplus pipeable fncts.Struct map
  * @tsplus location "@fncts/base/data/Struct/api"
  */
-export declare function map_<A, B>(self: Struct<A>, f: (a: A[keyof A]) => B): Struct<Record<keyof A, B>>;
+export declare function map<A, B>(f: (a: A[keyof A]) => B): (self: Struct<A>) => Struct<Record<keyof A, B>>;
 /**
  * @tsplus getter fncts.Struct keys
  * @tsplus location "@fncts/base/data/Struct/api"

package/data/Tag/constructors.d.ts

@@ -1,7 +1,6 @@
 import { Tag } from "@fncts/base/data/Tag/definition";
 /**
  * @tsplus static fncts.TagOps __call
- * @fncts tag
  * @tsplus location "@fncts/base/data/Tag/constructors"
  */
-export declare function makeTag<T>(id?: string): Tag<T>;
+export declare function makeTag<T>(/** @fncts id */ id?: string): Tag<T>;