@fncts/base 0.0.20 → 0.0.22

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

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

@@ -1,12 +1,13 @@
 import { Datum } from "@fncts/base/data/Datum/definition";
-import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Refinement } from "@fncts/base/data/Refinement/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 { Eq } from "@fncts/base/data/Eq";
 import type * as P from "@fncts/base/typeclass";
-import type { Eq } from "@fncts/base/typeclass/Eq";
 import { Initial, Pending, Refresh, Replete } from "@fncts/base/data/Datum/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 /**
@@ -74,93 +75,92 @@ 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 some
  * @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 some<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 +172,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/Datum/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 export declare const enum DatumTag {
     Initial = "Initial",
     Pending = "Pending",

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/DecodeError/definition.d.ts

@@ -1,6 +1,7 @@
 import { Eval } from "@fncts/base/control/Eval/definition";
 import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
 import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { Literal } from "@fncts/typelevel/Any";
 export declare const DecodeErrorTypeId: unique symbol;
 export type DecodeErrorTypeId = typeof DecodeErrorTypeId;
 export declare abstract class DecodeError {
@@ -94,7 +95,7 @@ export declare class PrimitiveError extends DecodeError {
     constructor(actual: unknown, name: string);
     render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
 }
-export declare class LiteralError<A extends string | number | boolean> extends DecodeError {
+export declare class LiteralError<A extends Literal> extends DecodeError {
     readonly actual: unknown;
     readonly literals: Vector<A>;
     readonly _tag = "Literal";