@fncts/base 0.0.20 → 0.0.21

package/data/Const/api.d.ts

@@ -1,12 +1,12 @@
 import { Const } from "./definition.js";
 /**
- * @tsplus fluent fncts.Const map
+ * @tsplus pipeable fncts.Const map
  * @tsplus location "@fncts/base/data/Const/api"
  */
-export declare function map_<E, A, B>(self: Const<E, A>, _f: (a: A) => B): Const<E, B>;
+export declare function map<A, B>(_f: (a: A) => B): <E>(self: Const<E, A>) => Const<E, B>;
 /**
  * @tsplus static fncts.ConstOps make
  * @tsplus static fncts.ConstOps __call
  * @tsplus location "@fncts/base/data/Const/api"
  */
-export declare function mkConst<E, A = never>(e: E): Const<E, A>;
+export declare function makeConst<E, A = never>(e: E): Const<E, A>;

package/data/Datum/api.d.ts

@@ -4,6 +4,7 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Either } from "@fncts/base/data/Either/definition";
+import { HKT } from "@fncts/typelevel/HKT";
 import type { DatumF } from "@fncts/base/data/Datum/definition";
 import type * as P from "@fncts/base/typeclass";
 import type { Eq } from "@fncts/base/typeclass/Eq";
@@ -74,93 +75,93 @@ export declare function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Repl
  */
 export declare function isLoading<A>(self: Datum<A>): self is Pending | Refresh<A>;
 /**
- * @tsplus fluent fncts.Datum elem
+ * @tsplus pipeable fncts.Datum elem
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function elem<A>(self: Datum<A>, a: A, /** @tsplus auto */ E: Eq<A>): boolean;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Datum<A>) => boolean;
 /**
- * @tsplus fluent fncts.Datum exists
+ * @tsplus pipeable fncts.Datum exists
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function exists<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): self is Datum<B>;
-export declare function exists<A>(self: Datum<A>, p: Predicate<A>): boolean;
+export declare function exists<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => self is Datum<B>;
+export declare function exists<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
 /**
- * @tsplus fluent fncts.Datum extend
+ * @tsplus pipeable fncts.Datum extend
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function extend<A, B>(self: Datum<A>, f: (wa: Datum<A>) => B): Datum<B>;
+export declare function extend<A, B>(f: (wa: Datum<A>) => B): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum filter
+ * @tsplus pipeable fncts.Datum filter
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function filter<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): Datum<B>;
-export declare function filter<A>(self: Datum<A>, p: Predicate<A>): Datum<A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => Datum<B>;
+export declare function filter<A>(p: Predicate<A>): (self: Datum<A>) => Datum<A>;
 /**
- * @tsplus fluent fncts.Datum filterMap
+ * @tsplus pipeable fncts.Datum filterMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function filterMap<A, B>(self: Datum<A>, f: (a: A) => Maybe<B>): Datum<B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum flatMap
+ * @tsplus pipeable fncts.Datum flatMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function flatMap<A, B>(self: Datum<A>, f: (a: A) => Datum<B>): Datum<B>;
+export declare function flatMap<A, B>(f: (a: A) => Datum<B>): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum foldLeft
+ * @tsplus pipeable fncts.Datum foldLeft
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldLeft<A, B>(self: Datum<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: Datum<A>) => B;
 /**
- * @tsplus fluent fncts.Datum foldMap
+ * @tsplus pipeable fncts.Datum foldMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldMap<A, M>(self: Datum<A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Datum<A>) => M;
 /**
- * @tsplus fluent fncts.Datum foldRight
+ * @tsplus pipeable fncts.Datum foldRight
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldRight<A, B>(self: Datum<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: Datum<A>) => B;
 /**
- * @tsplus fluent fncts.Datum getOrElse
+ * @tsplus pipeable fncts.Datum getOrElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function getOrElse<A, B>(self: Datum<A>, b: Lazy<B>): A | B;
+export declare function getOrElse<B>(b: Lazy<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => B | A;
 /**
- * @tsplus fluent fncts.Datum match
+ * @tsplus pipeable fncts.Datum match
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function match<A, B, C, D, E>(self: Datum<A>, cases: {
+export declare function match<A, B, C, D, E>(cases: {
     Initial: () => B;
     Pending: () => C;
     Refresh: (a: A) => D;
     Replete: (a: A) => E;
-}): B | C | D | E;
+}): (self: Datum<A>) => B | C | D | E;
 /**
- * @tsplus fluent fncts.Datum match2
+ * @tsplus pipeable fncts.Datum match2
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function match2<A, B, C>(self: Datum<A>, onEmpty: (isLoading: boolean) => B, onValue: (a: A, isLoading: boolean) => C): B | C;
+export declare function match2<A, B, C>(onEmpty: (isLoading: boolean) => B, onValue: (a: A, isLoading: boolean) => C): (self: Datum<A>) => B | C;
 /**
- * @tsplus fluent fncts.Datum map
+ * @tsplus pipeable fncts.Datum map
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function map<A, B>(self: Datum<A>, f: (a: A) => B): Datum<B>;
+export declare function map<A, B>(f: (a: A) => B): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum orElse
+ * @tsplus pipeable fncts.Datum orElse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function orElse<A, B>(self: Datum<A>, that: Lazy<Datum<B>>): Datum<A | B>;
+export declare function orElse<B>(that: Lazy<Datum<B>>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<B | A>;
 /**
- * @tsplus fluent fncts.Datum partition
+ * @tsplus pipeable fncts.Datum partition
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function partition<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): [Datum<A>, Datum<B>];
-export declare function partition<A>(self: Datum<A>, p: Predicate<A>): [Datum<A>, Datum<A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => [Datum<A>, Datum<B>];
+export declare function partition<A>(p: Predicate<A>): (self: Datum<A>) => [Datum<A>, Datum<A>];
 /**
- * @tsplus fluent fncts.Datum partitionMap
+ * @tsplus pipeable fncts.Datum partitionMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function partitionMap<A, B, C>(self: Datum<A>, f: (a: A) => Either<B, C>): [Datum<B>, Datum<C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Datum<A>) => [Datum<B>, Datum<C>];
 /**
  * @tsplus getter fncts.Datum toPending
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -172,17 +173,18 @@ export declare function toPending<A>(self: Datum<A>): Datum<A>;
  */
 export declare function toReplete<A>(self: Datum<A>): Datum<A>;
 /**
- * @tsplus fluent fncts.Datum traverse
+ * @tsplus getter fncts.Datum traverse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
+export declare function _traverse<A>(self: Datum<A>): <G extends import("@fncts/typelevel/HKT").HKT, GC = import("@fncts/typelevel/HKT").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/Datum/definition").Datum<B>>;
 export declare const traverse: P.Traversable<DatumF>["traverse"];
 /**
- * @tsplus fluent fncts.Datum zip
+ * @tsplus pipeable fncts.Datum zip
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function zip<A, B>(self: Datum<A>, that: Datum<B>): Datum<Zipped.Make<A, B>>;
+export declare function zip<B>(that: Datum<B>): <A>(self: import("@fncts/base/data/Datum/definition").Datum<A>) => import("@fncts/base/data/Datum/definition").Datum<Zipped.Make<A, B>>;
 /**
- * @tsplus fluent fncts.Datum zipWith
+ * @tsplus pipeable fncts.Datum zipWith
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function zipWith<A, B, C>(self: Datum<A>, that: Datum<B>, f: (a: A, b: B) => C): Datum<C>;
+export declare function zipWith<A, B, C>(that: Datum<B>, f: (a: A, b: B) => C): (self: Datum<A>) => Datum<C>;

package/data/DatumEither/api.d.ts

@@ -4,6 +4,7 @@ import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { HKT } from "@fncts/typelevel/HKT";
 import { Zipped } from "@fncts/base/data/Zipped";
 import type { DatumEitherF } from "@fncts/base/data/DatumEither/definition";
 import type * as P from "@fncts/base/typeclass";
@@ -38,110 +39,110 @@ export declare function repleteLeft<E, A = never>(e: E): DatumEither<E, A>;
  */
 export declare function repleteRight<E = never, A = never>(a: A): DatumEither<E, A>;
 /**
- * @tsplus fluent fncts.DatumEither bimap
+ * @tsplus pipeable fncts.DatumEither bimap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const bimap: <E, A, E1, B>(self: DatumEither<E, A>, f: (e: E) => E1, g: (a: A) => B) => DatumEither<E1, B>;
+export declare const bimap: <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E1, B>;
 /**
- * @tsplus fluent fncts.DatumEither exists
+ * @tsplus pipeable fncts.DatumEither exists
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function exists<E, A, B extends A>(self: DatumEither<E, A>, p: Refinement<A, B>): self is DatumEither<E, B>;
-export declare function exists<E, A>(self: DatumEither<E, A>, p: Predicate<A>): boolean;
+export declare function exists<A, B extends A>(p: Refinement<A, B>): <E>(self: DatumEither<E, A>) => self is DatumEither<E, B>;
+export declare function exists<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => boolean;
 /**
- * @tsplus fluent fncts.DatumEither filter
+ * @tsplus pipeable fncts.DatumEither filter
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function filter<E, A, B extends A>(self: DatumEither<E, A>, p: Refinement<A, B>): DatumEither<E, B>;
-export declare function filter<E, A>(self: DatumEither<E, A>, p: Predicate<A>): DatumEither<E, A>;
+export declare function filter<A, B extends A>(p: Refinement<A, B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
+export declare function filter<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => DatumEither<E, A>;
 /**
- * @tsplus fluent fncts.DatumEither filterMap
+ * @tsplus pipeable fncts.DatumEither filterMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function filterMap<E, A, B>(self: DatumEither<E, A>, f: (a: A) => Maybe<B>): DatumEither<E, B>;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>;
 /**
- * @tsplus fluent fncts.DatumEither flatMap
+ * @tsplus pipeable fncts.DatumEither flatMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const flatMap: <E, A, E1, B>(self: DatumEither<E, A>, f: (a: A) => DatumEither<E1, B>) => DatumEither<E | E1, B>;
+export declare const flatMap: <A, E1, B>(f: (a: A) => DatumEither<E1, B>) => <E>(self: DatumEither<E, A>) => DatumEither<E | E1, B>;
 /**
- * @tsplus fluent fncts.DatumEither foldLeft
+ * @tsplus pipeable fncts.DatumEither foldLeft
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldLeft<E, A, B>(self: DatumEither<E, A>, b: B, f: (b: B, a: A) => B): B;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
 /**
- * @tsplus fluent fncts.DatumEither foldMap
+ * @tsplus pipeable fncts.DatumEither foldMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldMap<E, A, M>(self: DatumEither<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => M;
 /**
- * @tsplus fluent fncts.DatumEither foldRight
+ * @tsplus pipeable fncts.DatumEither foldRight
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function foldRight<E, A, B>(self: DatumEither<E, A>, b: B, f: (a: A, b: B) => B): B;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B;
 /**
- * @tsplus fluent fncts.DatumEither getOrElse
+ * @tsplus pipeable fncts.DatumEither getOrElse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function getOrElse<E, A, B, C>(self: DatumEither<E, A>, onEmpty: () => B, onLeft: (e: E) => C): A | B | C;
+export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => B | C | A;
 /**
- * @tsplus fluent fncts.DatumEither map
+ * @tsplus pipeable fncts.DatumEither map
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const map: <E, A, B>(self: DatumEither<E, A>, f: (a: A) => B) => DatumEither<E, B>;
+export declare const map: <E, A, B>(f: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E, B>;
 /**
- * @tsplus fluent fncts.DatumEither mapLeft
+ * @tsplus pipeable fncts.DatumEither mapLeft
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const mapLeft: <E, A, E1>(self: DatumEither<E, A>, f: (e: E) => E1) => DatumEither<E1, A>;
+export declare const mapLeft: <E, E1>(f: (e: E) => E1) => <A>(self: DatumEither<E, A>) => DatumEither<E1, A>;
 /**
- * @tsplus fluent fncts.DatumEither match
+ * @tsplus pipeable fncts.DatumEither match
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function match<E, A, B, C, D, F>(self: DatumEither<E, A>, onInitial: () => B, onPending: () => C, onLeft: (e: E, isLoading: boolean) => D, onRight: (a: A, isLoading: boolean) => F): B | C | D | F;
+export declare function match<E, A, B, C, D, F>(onInitial: () => B, onPending: () => C, onLeft: (e: E, isLoading: boolean) => D, onRight: (a: A, isLoading: boolean) => F): (self: DatumEither<E, A>) => B | C | D | F;
 /**
- * @tsplus fluent fncts.DatumEither match3
+ * @tsplus pipeable fncts.DatumEither match3
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function match3<E, A, B, C, D>(self: DatumEither<E, A>, onEmpty: (loading: boolean) => B, onLeft: (e: E, loading: boolean) => C, onRight: (a: A, loading: boolean) => D): B | C | D;
+export declare function match3<E, A, B, C, D>(onEmpty: (loading: boolean) => B, onLeft: (e: E, loading: boolean) => C, onRight: (a: A, loading: boolean) => D): (self: DatumEither<E, A>) => B | C | D;
 /**
- * @tsplus fluent fncts.DatumEither matchAll
+ * @tsplus pipeable fncts.DatumEither matchAll
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function matchAll<E, A, B, C, D, F, G, H>(self: DatumEither<E, A>, cases: {
+export declare function matchAll<E, A, B, C, D, F, G, H>(cases: {
     Initial: () => B;
     Pending: () => C;
     RefreshLeft: (e: E) => D;
     RefreshRight: (a: A) => F;
     RepleteLeft: (e: E) => G;
     RepleteRight: (a: A) => H;
-}): B | C | D | F | G | H;
+}): (self: DatumEither<E, A>) => B | C | D | F | G | H;
 /**
- * @tsplus fluent fncts.DatumEither matchEither
+ * @tsplus pipeable fncts.DatumEither matchEither
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const matchEither: <E, A, B, C, D, F>(self: DatumEither<E, A>, cases: {
+export declare const matchEither: <E, A, B, C, D, F>(cases: {
     Initial: () => B;
     Pending: () => C;
     Refresh: (value: Either<E, A>) => D;
     Replete: (value: Either<E, A>) => F;
-}) => B | C | D | F;
+}) => (self: DatumEither<E, A>) => B | C | D | F;
 /**
- * @tsplus fluent fncts.DatumEither orElse
+ * @tsplus pipeable fncts.DatumEither orElse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const orElse: <E, A, E1, B>(self: DatumEither<E, A>, that: Lazy<DatumEither<E1, B>>) => DatumEither<E | E1, A | B>;
+export declare const orElse: <E1, B>(that: Lazy<DatumEither<E1, B>>) => <E, A>(self: DatumEither<E, A>) => DatumEither<E | E1, A | B>;
 /**
- * @tsplus fluent fncts.DatumEither partition
+ * @tsplus pipeable fncts.DatumEither partition
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function partition<E, A, B extends A>(self: DatumEither<E, A>, p: Refinement<A, B>): [DatumEither<E, A>, DatumEither<E, B>];
-export declare function partition<E, A>(self: DatumEither<E, A>, p: Predicate<A>): [DatumEither<E, A>, DatumEither<E, A>];
+export declare function partition<A, B extends A>(p: Refinement<A, B>): <E>(self: DatumEither<E, A>) => [DatumEither<E, A>, DatumEither<E, B>];
+export declare function partition<A>(p: Predicate<A>): <E>(self: DatumEither<E, A>) => [DatumEither<E, A>, DatumEither<E, A>];
 /**
- * @tsplus fluent fncts.DatumEither partitionMap
+ * @tsplus pipeable fncts.DatumEither partitionMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function partitionMap<E, A, B, C>(self: DatumEither<E, A>, f: (a: A) => Either<B, C>): [DatumEither<E, B>, DatumEither<E, C>];
+export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): <E>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => [import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>, import("@fncts/base/data/DatumEither/definition").DatumEither<E, C>];
 /**
  * @tsplus getter fncts.DatumEither toPending
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -153,17 +154,18 @@ export declare const toPending: <E, A>(self: DatumEither<E, A>) => DatumEither<E
  */
 export declare const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A>;
 /**
- * @tsplus fluent fncts.DatumEither traverse
+ * @tsplus getter fncts.DatumEither traverse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
+export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends import("@fncts/typelevel/HKT.js").HKT, GC = import("@fncts/typelevel/HKT.js").HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => import("@fncts/typelevel/HKT.js").HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, import("@fncts/base/data/DatumEither/definition").DatumEither<E, B>>;
 export declare const traverse: P.Traversable<DatumEitherF>["traverse"];
 /**
- * @tsplus fluent fncts.DatumEither zipWith
+ * @tsplus pipeable fncts.DatumEither zipWith
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare const zipWith: <E, A, E1, B, C>(self: DatumEither<E, A>, that: DatumEither<E1, B>, f: (a: A, b: B) => C) => DatumEither<E | E1, C>;
+export declare const zipWith: <A, E1, B, C>(that: DatumEither<E1, B>, f: (a: A, b: B) => C) => <E>(self: DatumEither<E, A>) => DatumEither<E | E1, C>;
 /**
- * @tsplus fluent fncts.DatumEither zip
+ * @tsplus pipeable fncts.DatumEither zip
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function zip<E, A, E1, B>(self: DatumEither<E, A>, that: DatumEither<E1, B>): DatumEither<E | E1, Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: DatumEither<E1, B>): <E, A>(self: import("@fncts/base/data/DatumEither/definition").DatumEither<E, A>) => import("@fncts/base/data/DatumEither/definition").DatumEither<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;

package/data/Decoder/api.d.ts

@@ -5,10 +5,10 @@ import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
 /**
- * @tsplus fluent fncts.Decoder __call
+ * @tsplus pipeable fncts.Decoder __call
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare function decode<A>(self: Decoder<A>, input: unknown): These<DecodeError, A>;
+export declare function decode(input: unknown): <A>(self: Decoder<A>) => import("../These").These<DecodeError, A>;
 export declare function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A>;
 /**
  * @tsplus implicit

package/data/Duration/api.d.ts

@@ -30,25 +30,25 @@ export declare function hours(self: number): Duration;
  */
 export declare function days(self: number): Duration;
 /**
- * @tsplus operator fncts.Duration *
+ * @tsplus pipeable-operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function mult(self: Duration, multiplicand: number): import("./definition").Duration;
+export declare function product(multiplicand: number): (self: Duration) => Duration;
 /**
  * @tsplus operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function multInverted(multiplicand: number, self: Duration): import("./definition").Duration;
+export declare function multiplyInverted(multiplicand: number, self: Duration): import("./definition").Duration;
 /**
- * @tsplus operator fncts.Duration +
+ * @tsplus pipeable-operator fncts.Duration +
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function sum(self: Duration, that: Duration): Duration;
+export declare function sum(that: Duration): (self: Duration) => Duration;
 /**
- * @tsplus operator fncts.Duration -
+ * @tsplus pipeable-operator fncts.Duration -
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function difference(self: Duration, that: Duration): Duration;
+export declare function difference(that: Duration): (self: Duration) => Duration;
 /**
  * @tsplus static fncts.DurationOps fromInterval
  * @tsplus location "@fncts/base/data/Duration/api"

package/data/Either/api/align.d.ts

@@ -1,3 +1,7 @@
 import type { These } from "../../These.js";
 import type { Either } from "../definition.js";
-export declare function align_<E1, A, E2, B>(self: Either<E1, A>, fb: Either<E2, B>): Either<E1 | E2, These<A, B>>;
+/**
+ * @tsplus pipeable fncts.Either align
+ * @tsplus location "@fncts/base/data/Either/api/align"
+ */
+export declare function align<E2, B>(fb: Either<E2, B>): <E1, A>(self: Either<E1, A>) => Either<E2 | E1, These<A, B>>;

package/data/Either/api/alignWith.d.ts

@@ -1,7 +1,7 @@
 import type { Either } from "../definition.js";
 import { These } from "../../These.js";
 /**
- * @tsplus fluent fncts.Either alignWith
+ * @tsplus pipeable fncts.Either alignWith
  * @tsplus location "@fncts/base/data/Either/api/alignWith"
  */
-export declare function alignWith_<E1, A, E2, B, C>(self: Either<E1, A>, fb: Either<E2, B>, f: (_: These<A, B>) => C): Either<E1 | E2, C>;
+export declare function alignWith<A, E2, B, C>(fb: Either<E2, B>, f: (_: These<A, B>) => C): <E1>(self: Either<E1, A>) => Either<E2 | E1, C>;