@fncts/base 0.0.20 → 0.0.21

package/data/Either/api.d.ts

@@ -1,56 +1,57 @@
 import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { HKT } from "@fncts/typelevel/HKT";
 import { Zipped } from "@fncts/base/data/Zipped";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type * as P from "../../typeclass.js";
 import type { EitherF } from "./definition.js";
 import { Left, Right } from "./definition.js";
 /**
- * @tsplus fluent fncts.Either ap
+ * @tsplus pipeable fncts.Either ap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function ap_<E1, A, E2, B>(self: Either<E1, (a: A) => B>, fa: Either<E2, A>): Either<E1 | E2, B>;
+export declare function ap<A, E2>(fa: Either<E2, A>): <E1, B>(self: import("./definition.js").Either<E1, (a: A) => B>) => import("./definition.js").Either<E2 | E1, B>;
 /**
- * @tsplus fluent fncts.Either bimap
+ * @tsplus pipeable fncts.Either bimap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function bimap_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => E2, g: (a: A) => B): Either<E2, B>;
+export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (self: Either<E1, A>) => Either<E2, B>;
 /**
- * @tsplus fluent fncts.Either catchAll
+ * @tsplus pipeable fncts.Either catchAll
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchAll_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Either<E2, B>): Either<E2, A | B>;
+export declare function catchAll<E1, E2, B>(f: (e: E1) => Either<E2, B>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, B | A>;
 /**
- * @tsplus fluent fncts.Either catchJust
+ * @tsplus pipeable fncts.Either catchJust
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchJust_<E1, A, E2, B>(self: Either<E1, A>, f: (e: E1) => Maybe<Either<E2, B>>): Either<E1 | E2, A | B>;
+export declare function catchJust<E1, E2, B>(f: (e: E1) => Maybe<Either<E2, B>>): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E1 | E2, B | A>;
 /**
- * @tsplus fluent fncts.Either catchMap
+ * @tsplus pipeable fncts.Either catchMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function catchMap_<E, A, B>(self: Either<E, A>, f: (e: E) => B): Either<never, A | B>;
+export declare function catchMap<E, B>(f: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<never, B | A>;
 /**
- * @tsplus fluent fncts.Either flatMap
+ * @tsplus pipeable fncts.Either flatMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function flatMap_<E1, A, E2, B>(self: Either<E1, A>, f: (a: A) => Either<E2, B>): Either<E1 | E2, B>;
+export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B>;
 /**
- * @tsplus fluent fncts.Either foldLeft
+ * @tsplus pipeable fncts.Either foldLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldLeft_<E, A, B>(self: Either<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("./definition.js").Either<E, A>) => B;
 /**
- * @tsplus fluent fncts.Either foldRight
+ * @tsplus pipeable fncts.Either foldRight
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldRight_<E, A, B>(self: Either<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("./definition.js").Either<E, A>) => B;
 /**
- * @tsplus fluent fncts.Either foldMap
+ * @tsplus pipeable fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMap_<E, A, M>(self: Either<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("./definition.js").Either<E, A>) => M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -62,10 +63,10 @@ export declare function getLeft<E, A>(self: Either<E, A>): Maybe<E>;
  */
 export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
 /**
- * @tsplus fluent fncts.Either getOrElse
+ * @tsplus pipeable fncts.Either getOrElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function getOrElse_<E, A, B>(self: Either<E, A>, orElse: (e: E) => B): A | B;
+export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: import("./definition.js").Either<E, A>) => B | A;
 /**
  * @tsplus static fncts.EitherOps isEither
  * @tsplus location "@fncts/base/data/Either/api"
@@ -83,74 +84,67 @@ export declare function isLeft<E, A>(self: Either<E, A>): self is Left<E>;
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function isRight<E, A>(self: Either<E, A>): self is Right<A>;
-/**
- * @tsplus fluent fncts.Either map
- * @tsplus location "@fncts/base/data/Either/api"
- */
-export declare function map_<E, A, B>(self: Either<E, A>, f: (a: A) => B): Either<E, B>;
 /**
  * @tsplus static fncts.EitherOps map
  * @tsplus pipeable fncts.Either map
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare const map: <A, B>(f: (a: A) => B) => <E>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E, B>;
+export declare function map<A, B>(f: (a: A) => B): <E>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E, B>;
 /**
- * @tsplus fluent fncts.Either mapLeft
+ * @tsplus pipeable fncts.Either mapLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function mapLeft_<E1, A, E2>(self: Either<E1, A>, f: (e: E1) => E2): Either<E2, A>;
+export declare function mapLeft<E1, E2>(f: (e: E1) => E2): <A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2, A>;
 /**
  * @tsplus getter fncts.Either value
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function merge<E, A>(self: Either<E, A>): E | A;
 /**
- * @tsplus fluent fncts.Either orElse
+ * @tsplus pipeable fncts.Either orElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function orElse_<E1, A, E2, B>(self: Either<E1, A>, that: Lazy<Either<E2, B>>): Either<E1 | E2, A | B>;
+export declare function orElse<E2, B>(that: Lazy<Either<E2, B>>): <E1, A>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, B | A>;
 /**
  * @tsplus getter fncts.Either swap
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
 /**
- * @tsplus fluent fncts.Either traverse
+ * @tsplus getter fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
+export declare function _traverse<E, A>(self: Either<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("./definition.js").Either<E, B>>;
 export declare const traverse_: P.Traversable<EitherF>["traverse"];
 /**
- * @tsplus fluent fncts.Either zipWith
+ * @tsplus pipeable fncts.Either zipWith
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zipWith_<E1, A, E2, B, C>(self: Either<E1, A>, fb: Either<E2, B>, f: (a: A, b: B) => C): Either<E1 | E2, C>;
+export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: import("./definition.js").Either<E1, A>) => import("./definition.js").Either<E2 | E1, C>;
 /**
- * @tsplus fluent fncts.Either zip
+ * @tsplus pipeable fncts.Either zip
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zip<E, A, E1, B>(self: Either<E, A>, that: Either<E1, B>): Either<E | E1, Zipped.Make<A, B>>;
+export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: import("./definition.js").Either<E, A>) => import("./definition.js").Either<E1 | E, import("../Zipped.js").Zipped.Make<A, B>>;
 /**
- * @tsplus fluent fncts.Either filterMap
+ * @tsplus pipeable fncts.Either filterMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function filterMap<E, A, B>(self: Either<E, A>, f: (a: A) => Maybe<B>, 
-/** @tsplus auto */ M: P.Monoid<E>): Either<E, B>;
+export declare function filterMap<E, A, B>(f: (a: A) => Maybe<B>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => Either<E, B>;
 /**
- * @tsplus fluent fncts.Either filter
+ * @tsplus pipeable fncts.Either filter
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function filter<E, A>(self: Either<E, A>, f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): Either<E, A>;
+export declare function filter<E, A>(f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => Either<E, A>;
 /**
- * @tsplus fluent fncts.Either partitionMap
+ * @tsplus pipeable fncts.Either partitionMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function partitionMap<E, A, B, C>(self: Either<E, A>, f: (a: A) => Either<B, C>, 
-/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, B>, Either<E, C>];
+export declare function partitionMap<E, A, B, C>(f: (a: A) => Either<B, C>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => readonly [Either<E, B>, Either<E, C>];
 /**
- * @tsplus fluent fncts.Either partition
+ * @tsplus pipeable fncts.Either partition
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function partition<E, A>(self: Either<E, A>, p: Predicate<A>, 
-/** @tsplus auto */ M: P.Monoid<E>): readonly [Either<E, A>, Either<E, A>];
+export declare function partition<E, A>(p: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => readonly [Either<E, A>, Either<E, A>];
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/constructors.d.ts

@@ -1,5 +1,5 @@
-import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type { Nullable } from "@fncts/base/types";
@@ -18,15 +18,15 @@ export declare function left<E = never, A = never>(e: E): Either<E, A>;
 export declare function right<E = never, A = never>(a: A): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromMaybe
- * @tsplus fluent fncts.Maybe toEither
+ * @tsplus pipeable fncts.Maybe toEither
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function fromMaybe_<E, A>(self: Maybe<A>, nothing: Lazy<E>): Either<E, A>;
+export declare function fromMaybe<E>(nothing: Lazy<E>): <A>(self: import("../Maybe.js").Maybe<A>) => Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromNullable
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function fromNullable_<E, A>(value: A, nullable: Lazy<E>): Either<E, NonNullable<A>>;
+export declare function fromNullable<E, A>(value: A, nullable: Lazy<E>): Either<E, NonNullable<A>>;
 /**
  * @tsplus static fncts.EitherOps fromNullableK
  * @tsplus location "@fncts/base/data/Either/constructors"
@@ -36,8 +36,8 @@ export declare function fromNullableK<E, P extends ReadonlyArray<unknown>, A>(f:
  * @tsplus static fncts.EitherOps fromPredicate
  * @tsplus location "@fncts/base/data/Either/constructors"
  */
-export declare function fromPredicate_<E, A, B extends A>(value: A, p: Refinement<A, B>, otherwise: (a: A) => E): Either<E, B>;
-export declare function fromPredicate_<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A>;
+export declare function fromPredicate<E, A, B extends A>(value: A, p: Refinement<A, B>, otherwise: (a: A) => E): Either<E, B>;
+export declare function fromPredicate<E, A>(value: A, p: Predicate<A>, otherwise: (a: A) => E): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps tryCatch
  * @tsplus location "@fncts/base/data/Either/constructors"

package/data/Either/destructors.d.ts

@@ -1,6 +1,6 @@
 import { Either } from "@fncts/base/data/Either/definition";
 /**
- * @tsplus fluent fncts.Either match
+ * @tsplus pipeable fncts.Either match
  * @tsplus location "@fncts/base/data/Either/destructors"
  */
-export declare function match_<E, A, B, C>(self: Either<E, A>, left: (e: E) => B, right: (a: A) => C): B | C;
+export declare function match<E, A, B, C>(left: (e: E) => B, right: (a: A) => C): (self: Either<E, A>) => B | C;

package/data/EitherT/api.d.ts

@@ -32,29 +32,29 @@ export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W,
  * @tsplus static fncts.EitherTOps map
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E, A, B>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>, f: (a: A) => B) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>;
+export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (a: A) => B) => <K, Q, W, X, I, S, R, FE, E>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, B>>;
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E, A, E1>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>, f: (e: E) => E1) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>;
+export declare function mapLeft<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, E1>(f: (e: E) => E1) => <K, Q, W, X, I, S, R, FE, A>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, A>>;
 /**
  * @tsplus static fncts.EitherTOps bimap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E, A, E1, B>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>, f: (e: E) => E1, g: (a: A) => B) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>>;
+export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>): <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => <K, Q, W, X, I, S, R, FE>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E1, B>>;
 /**
  * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, E, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>, f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, import("../Either.js").Either<E | E1, B>>;
+export declare function flatMap<F extends HKT, FC>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, FE, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: A) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "K", K, K1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "Q", Q, Q1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "W", W, W1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "X", X, X1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "I", I, I1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "S", S, S1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "R", R, R1>, import("@fncts/typelevel/HKT.js").HKT.Intro<F, "E", FE, FE1>, import("../Either.js").Either<E1, B>>) => <E>(self: import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, import("../Either.js").Either<E, A>>) => import("@fncts/typelevel/HKT.js").HKT.Kind<F, FC, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "K", [K, K1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "Q", [Q, Q1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "W", [W, W1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "X", [X, X1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "I", [I, I1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "S", [S, S1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "R", [R, R1]>, import("@fncts/typelevel/HKT.js").HKT.Mix<F, "E", [FE, FE1]>, import("../Either.js").Either<E1 | E, B>>;
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function zipWith<F extends HKT, FC = HKT.None>(F: P.Apply<F, FC>): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>, that: HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E1, B>>, f: (a: A, b: B) => C) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E | E1, C>>;
+export declare function zipWith<F extends HKT, FC = HKT.None>(F: P.Apply<F, FC>): <K, Q, W, X, I, S, R, EF, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B, C>(that: HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E1, B>>, f: (a: A, b: B) => C) => <E>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>) => HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E | E1, C>>;
 /**
  * @tsplus static fncts.EitherTOps orElse
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function orElse<F extends HKT, FC = HKT.None>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, EF, E, A, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>, that: Lazy<HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E1, B>>>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [EF, EF1]>, Either<E | E1, A | B>>;
+export declare function orElse<F extends HKT, FC = HKT.None>(F: P.Monad<F, FC>): <K, Q, W, X, I, S, R, EF, K1, Q1, W1, X1, I1, S1, R1, EF1, E1, B>(that: Lazy<HKT.Kind<F, FC, HKT.Intro<F, "K", K, K1>, HKT.Intro<F, "Q", Q, Q1>, HKT.Intro<F, "W", W, W1>, HKT.Intro<F, "X", X, X1>, HKT.Intro<F, "I", I, I1>, HKT.Intro<F, "S", S, S1>, HKT.Intro<F, "R", R, R1>, HKT.Intro<F, "E", EF, EF1>, Either<E1, B>>>) => <E, A>(fa: HKT.Kind<F, FC, K, Q, W, X, I, S, R, EF, Either<E, A>>) => HKT.Kind<F, FC, HKT.Mix<F, "K", [K, K1]>, HKT.Mix<F, "Q", [Q, Q1]>, HKT.Mix<F, "W", [W, W1]>, HKT.Mix<F, "X", [X, X1]>, HKT.Mix<F, "I", [I, I1]>, HKT.Mix<F, "S", [S, S1]>, HKT.Mix<F, "R", [R, R1]>, HKT.Mix<F, "E", [EF, EF1]>, Either<E | E1, A | B>>;

package/data/Encoder/api.d.ts

@@ -0,0 +1,73 @@
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { Brand } from "../Branded.js";
+import type { Check } from "@fncts/typelevel";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+import { Encoder } from "./definition.js";
+/**
+ * @tsplus static fncts.EncoderOps __call
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function makeEncoder<A>(encode: (inp: A) => unknown): Encoder<A>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const boolean: Encoder<boolean>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const number: Encoder<number>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const string: Encoder<number>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const _null: Encoder<null>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const date: Encoder<Date>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder lazy
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveLazy<A>(fn: (_: Encoder<A>) => Encoder<A>): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<_> 20
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [K in RequiredKeys<A>]: Encoder<A[K]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [K in OptionalKeys<A>]: Encoder<NonNullable<A[K]>>;
+        }
+    ])
+] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<|> 30
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveUnion<A extends Array<unknown>>(...elements: {
+    [K in keyof A]: [Guard<A[K]>, Encoder<A[K]>];
+}): Encoder<A[number]>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveEmptyRecord<A extends {}>(..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never): Encoder<A>;

package/data/Encoder/definition.d.ts

@@ -0,0 +1,12 @@
+export declare const EncoderTypeId: unique symbol;
+export type EncoderTypeId = typeof EncoderTypeId;
+/**
+ * @tsplus type fncts.Encoder
+ * @tsplus companion fncts.EncoderOps
+ * @tsplus derive nominal
+ */
+export declare class Encoder<in out A> {
+    readonly encode: (inp: A) => unknown;
+    readonly _typeId: EncoderTypeId;
+    constructor(encode: (inp: A) => unknown);
+}

package/data/Encoder.d.ts

@@ -0,0 +1,2 @@
+export * from "./Encoder/api.js";
+export * from "./Encoder/definition.js";

package/data/Environment/api.d.ts

@@ -1,12 +1,12 @@
-import { Environment } from "@fncts/base/data/Environment/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
+import { Environment } from "@fncts/base/data/Environment/definition";
 import { Has } from "@fncts/base/typeclass/Has";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 /**
- * @tsplus fluent fncts.Environment add
+ * @tsplus pipeable fncts.Environment add
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function add<R, H extends S, S = H>(self: Environment<R>, service: H, tag: Tag<S>): Environment<R | S>;
+export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<S | R>;
 /**
  * @tsplus static fncts.EnvironmentOps empty
  * @tsplus location "@fncts/base/data/Environment/api"
@@ -14,39 +14,39 @@ export declare function add<R, H extends S, S = H>(self: Environment<R>, service
 export declare const empty: import("./definition").Environment<never>;
 type Tags<R> = R extends infer S ? Tag<S> : never;
 /**
- * @tsplus fluent fncts.Environment get
+ * @tsplus pipeable fncts.Environment get
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function get<R, T extends Tags<R>>(self: Environment<R>, tag: T): T extends Tag<infer S> ? S : never;
+export declare function get<R, T extends Tags<R>>(tag: T): (self: Environment<R>) => T extends import("../Tag").Tag<infer S> ? S : never;
 /**
- * @tsplus fluent fncts.Environment getMaybe
+ * @tsplus pipeable fncts.Environment getMaybe
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function getMaybe<R extends Has<S>, S>(self: Environment<R>, tag: Tag<S>): Maybe<S>;
+export declare function getMaybe<S>(tag: Tag<S>): <R extends import("../../typeclass").Has<S>>(self: import("./definition").Environment<R>) => Maybe<S>;
 /**
  * @tsplus static fncts.EnvironmentOps __call
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare function make(): Environment<never>;
 /**
- * @tsplus operator fncts.Environment +
- * @tsplus fluent fncts.Environment union
+ * @tsplus pipeable-operator fncts.Environment +
+ * @tsplus pipeable fncts.Environment union
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function union<R, R1>(self: Environment<R>, that: Environment<R1>): Environment<R & R1>;
+export declare function union<R1>(that: Environment<R1>): <R>(self: import("./definition").Environment<R>) => import("./definition").Environment<R & R1>;
 /**
  * @tsplus getter fncts.Environment clean
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare function clean<R>(self: Environment<R>): Environment<R>;
 /**
- * @tsplus fluent fncts.Environment unsafeGet
+ * @tsplus pipeable fncts.Environment unsafeGet
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function unsafeGet<R, S>(self: Environment<R>, tag: Tag<S>): S;
+export declare function unsafeGet<S>(tag: Tag<S>): <R>(self: import("./definition").Environment<R>) => S;
 /**
- * @tsplus fluent fncts.Environment update
+ * @tsplus pipeable fncts.Environment update
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function update<R, S extends R>(self: Environment<R>, f: (s: S) => S, tag: Tag<S>): Environment<R>;
+export declare function update<R, S extends R>(f: (s: S) => S, tag: Tag<S>): (self: Environment<R>) => Environment<R>;
 export {};

package/data/EnvironmentPatch.d.ts

@@ -52,15 +52,15 @@ export type Concrete = AddService<any, any> | Combine<any, any, any> | Empty<any
  */
 export declare function concrete(_: EnvironmentPatch<any, any>): asserts _ is Concrete;
 /**
- * @tsplus fluent fncts.Environment.Patch __call
+ * @tsplus pipeable fncts.Environment.Patch __call
  * @tsplus location "@fncts/base/data/EnvironmentPatch"
  */
-export declare function apply<In, Out>(patch: EnvironmentPatch<In, Out>, environment: Environment<In>): Environment<Out>;
+export declare function apply<In>(environment: Environment<In>): <Out>(patch: EnvironmentPatch<In, Out>) => import("./Environment").Environment<Out>;
 /**
- * @tsplus fluent fncts.Environment.Patch combine
+ * @tsplus pipeable fncts.Environment.Patch combine
  * @tsplus location "@fncts/base/data/EnvironmentPatch"
  */
-export declare function combine<In, Out, Out2>(self: EnvironmentPatch<In, Out>, that: EnvironmentPatch<Out, Out2>): EnvironmentPatch<In, Out2>;
+export declare function combine<Out, Out2>(that: EnvironmentPatch<Out, Out2>): <In>(self: EnvironmentPatch<In, Out>) => EnvironmentPatch<In, Out2>;
 /**
  * @tsplus static fncts.Environment.PatchOps diff
  * @tsplus location "@fncts/base/data/EnvironmentPatch"

package/data/ExecutionStrategy.d.ts

@@ -33,13 +33,8 @@ export type ExecutionStrategy = Sequential | Concurrent | ConcurrentBounded;
 export interface ExecutionStrategyOps {
 }
 export declare const ExecutionStrategy: ExecutionStrategyOps;
-/**
- * @tsplus fluent fncts.ExecutionStrategy match
- * @tsplus location "@fncts/base/data/ExecutionStrategy"
- */
-export declare function match_<A, B, C>(strategy: ExecutionStrategy, sequential: () => A, concurrent: () => B, concurrentBounded: (fiberBound: number) => C): A | B | C;
 /**
  * @tsplus pipeable fncts.ExecutionStrategy match
  * @tsplus location "@fncts/base/data/ExecutionStrategy"
  */
-export declare function match<A, B, C>(sequential: () => A, concurrent: () => B, concurrentBounded: (fiberBound: number) => C): (strategy: ExecutionStrategy) => A | B | C;
+export declare function match_<A, B, C>(sequential: () => A, concurrent: () => B, concurrentBounded: (fiberBound: number) => C): (strategy: ExecutionStrategy) => A | B | C;

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