@fncts/base 0.0.20 → 0.0.21

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

package/data/Tag/definition.d.ts

@@ -12,7 +12,6 @@ export declare class Tag<in out T> implements Hashable, Equatable {
     readonly id: string;
     _T: (_: T) => T;
     readonly _typeId: TagTypeId;
-    private static counter;
     constructor(id: string);
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;

package/data/These/api.d.ts

@@ -18,56 +18,52 @@ export declare function isRight<E, A>(self: These<E, A>): self is Right<A>;
  */
 export declare function isBoth<E, A>(self: These<E, A>): self is Both<E, A>;
 /**
- * @tsplus fluent fncts.These map
+ * @tsplus pipeable fncts.These map
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function map<E, A, B>(self: These<E, A>, f: (a: A) => B): These<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, B>;
 /**
- * @tsplus fluent fncts.These mapLeft
+ * @tsplus pipeable fncts.These mapLeft
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function mapLeft<E, A, E1>(self: These<E, A>, f: (e: E) => E1): These<E1, A>;
+export declare function mapLeft<E, E1>(f: (e: E) => E1): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E1, A>;
 /**
- * @tsplus fluent fncts.These bimap
+ * @tsplus pipeable fncts.These bimap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function bimap<E, A, E1, B>(self: These<E, A>, f: (e: E) => E1, g: (a: A) => B): These<E1, B>;
+export declare function bimap<E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B): (self: These<E, A>) => These<E1, B>;
 /**
- * @tsplus fluent fncts.These zipWith
+ * @tsplus pipeable fncts.These zipWith
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zipWith<E, A, B, C>(self: These<E, A>, that: These<E, B>, f: (a: A, b: B) => C, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, C>;
+export declare function zipWith<E, A, B, C>(that: These<E, B>, f: (a: A, b: B) => C, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, C>;
 /**
- * @tsplus fluent fncts.These zip
+ * @tsplus pipeable fncts.These zip
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function zip<E, A, B>(self: These<E, A>, that: These<E, B>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, readonly [A, B]>;
+export declare function zip<E, B>(that: These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, readonly [A, B]>;
 /**
- * @tsplus fluent fncts.These ap
+ * @tsplus pipeable fncts.These ap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function ap<E, A, B>(self: These<E, (a: A) => B>, that: These<E, A>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+export declare function ap<E, A>(that: These<E, A>, /** @tsplus auto */ S: P.Semigroup<E>): <B>(self: import("@fncts/base/data/These/definition").These<E, (a: A) => B>) => import("@fncts/base/data/These/definition").These<E, B>;
 /**
- * @tsplus fluent fncts.These flatMap
+ * @tsplus pipeable fncts.These flatMap
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function flatMap<E, A, B>(self: These<E, A>, f: (a: A) => These<E, B>, 
-/** @tsplus auto */ S: P.Semigroup<E>): These<E, B>;
+export declare function flatMap<E, A, B>(f: (a: A) => These<E, B>, /** @tsplus auto */ S: P.Semigroup<E>): (self: These<E, A>) => These<E, B>;
 /**
- * @tsplus fluent fncts.These catchAll
+ * @tsplus pipeable fncts.These catchAll
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function catchAll_<E, A, B>(self: These<E, A>, f: (e: E) => These<E, B>): These<E, A | B>;
+export declare function catchAll<E, B>(f: (e: E) => These<E, B>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, B | A>;
 /**
  * @tsplus getter fncts.These condemn
  * @tsplus location "@fncts/base/data/These/api"
  */
 export declare function condemn<E, A>(self: These<E, A>): These<E, A>;
 /**
- * @tsplus fluent fncts.These condemnWhen
+ * @tsplus pipeable fncts.These condemnWhen
  * @tsplus location "@fncts/base/data/These/api"
  */
-export declare function condemnWhen<E, A>(self: These<E, A>, p: Predicate<E>): These<E, A>;
+export declare function condemnWhen<E>(p: Predicate<E>): <A>(self: import("@fncts/base/data/These/definition").These<E, A>) => import("@fncts/base/data/These/definition").These<E, A>;

package/data/These/destructors.d.ts

@@ -21,12 +21,12 @@ export declare function rightMaybe<E, A>(self: These<E, A>): Maybe<A>;
  */
 export declare function leftMaybe<E, A>(self: These<E, A>): Maybe<E>;
 /**
- * @tsplus fluent fncts.These match
+ * @tsplus pipeable fncts.These match
  * @tsplus location "@fncts/base/data/These/destructors"
  */
-export declare function match_<E, A, B, C, D>(self: These<E, A>, left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): B | C | D;
+export declare function match<E, A, B, C, D>(left: (e: E) => B, right: (a: A) => C, both: (e: E, a: A) => D): (self: These<E, A>) => B | C | D;
 /**
- * @tsplus fluent fncts.These match2
+ * @tsplus pipeable fncts.These match2
  * @tsplus location "@fncts/base/data/These/destructors"
  */
-export declare function match2<E, A, B, C>(self: These<E, A>, left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): B | C;
+export declare function match2<E, A, B, C>(left: (e: E) => B, right: (e: Maybe<E>, a: A) => C): (self: These<E, A>) => B | C;

package/data/Trace/api.d.ts

@@ -1,10 +1,10 @@
 import { Trace } from "@fncts/base/data/Trace/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 /**
- * @tsplus fluent fncts.Trace combine
+ * @tsplus pipeable fncts.Trace combine
  * @tsplus location "@fncts/base/data/Trace/api"
  */
-export declare function combine_(self: Trace, that: Trace): Trace;
+export declare function combine(that: Trace): (self: Trace) => Trace;
 /**
  * @tsplus getter fncts.Trace toJS
  * @tsplus location "@fncts/base/data/Trace/api"