@fncts/base 0.0.39 → 0.0.41

package/data/Datum/api.d.ts

@@ -1,6 +1,6 @@
 import { Datum } from "@fncts/base/data/Datum/definition";
-import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { Refinement } from "@fncts/base/data/Refinement/definition";
+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";
@@ -17,114 +17,91 @@ import { Zipped } from "@fncts/base/data/Zipped";
  */
 export declare function initial<A = never>(): Datum<A>;
 /**
- * @tsplus static fncts.DatumOps pending
- * @tsplus static fncts.Datum.PendingOps __call
+ * @tsplus pipeable fncts.Datum elem
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function pending<A = never>(): Datum<A>;
+export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Datum<A>) => boolean;
 /**
- * @tsplus static fncts.DatumOps refresh
- * @tsplus static fncts.Datum.RefreshOps __call
+ * @tsplus pipeable fncts.Datum extend
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function refresh<A>(value: A): Datum<A>;
+export declare function extend<A, B>(f: (wa: Datum<A>) => B): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus static fncts.DatumOps replete
- * @tsplus static fncts.Datum.RepleteOps __call
+ * @tsplus pipeable fncts.Datum filter
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function replete<A>(value: 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 getter fncts.Datum value
+ * @tsplus pipeable fncts.Datum filterMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function left<E, A>(self: Datum<A>): A | undefined;
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum isInitial
+ * @tsplus pipeable fncts.Datum flatMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function isInitial<A>(self: Datum<A>): self is Initial;
+export declare function flatMap<A, B>(f: (a: A) => Datum<B>): (self: Datum<A>) => Datum<B>;
 /**
- * @tsplus fluent fncts.Datum isPending
+ * @tsplus pipeable fncts.Datum foldLeft
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function isPending<A>(self: Datum<A>): self is Pending;
+export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Datum<A>) => B;
 /**
- * @tsplus fluent fncts.Datum isRefresh
+ * @tsplus pipeable fncts.Datum foldMap
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function isRefresh<A>(self: Datum<A>): self is Refresh<A>;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Datum<A>) => M;
 /**
- * @tsplus fluent fncts.Datum isReplete
+ * @tsplus pipeable fncts.Datum foldRight
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function isReplete<A>(self: Datum<A>): self is Replete<A>;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Datum<A>) => B;
+/**
+ * @tsplus pipeable fncts.Datum getOrElse
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function getOrElse<B>(b: Lazy<B>): <A>(self: Datum<A>) => A | B;
 /**
  * @tsplus fluent fncts.Datum isEmpty
  * @tsplus location "@fncts/base/data/Datum/api"
  */
 export declare function isEmpty<A>(self: Datum<A>): self is Initial | Pending;
 /**
- * @tsplus fluent fncts.Datum isNonEmpty
+ * @tsplus fluent fncts.Datum isInitial
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Replete<A>;
+export declare function isInitial<A>(self: Datum<A>): self is Initial;
 /**
  * @tsplus fluent fncts.Datum isLoading
  * @tsplus location "@fncts/base/data/Datum/api"
  */
 export declare function isLoading<A>(self: Datum<A>): self is Pending | Refresh<A>;
 /**
- * @tsplus pipeable fncts.Datum elem
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Datum<A>) => boolean;
-/**
- * @tsplus pipeable fncts.Datum some
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-export declare function some<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
-/**
- * @tsplus pipeable fncts.Datum extend
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-export declare function extend<A, B>(f: (wa: Datum<A>) => B): (self: Datum<A>) => Datum<B>;
-/**
- * @tsplus pipeable fncts.Datum filter
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-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 pipeable fncts.Datum filterMap
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): (self: Datum<A>) => Datum<B>;
-/**
- * @tsplus pipeable fncts.Datum flatMap
+ * @tsplus fluent fncts.Datum isNonEmpty
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function flatMap<A, B>(f: (a: A) => Datum<B>): (self: Datum<A>) => Datum<B>;
+export declare function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Replete<A>;
 /**
- * @tsplus pipeable fncts.Datum foldLeft
+ * @tsplus fluent fncts.Datum isPending
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): (self: Datum<A>) => B;
+export declare function isPending<A>(self: Datum<A>): self is Pending;
 /**
- * @tsplus pipeable fncts.Datum foldMap
+ * @tsplus fluent fncts.Datum isRefresh
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): (self: Datum<A>) => M;
+export declare function isRefresh<A>(self: Datum<A>): self is Refresh<A>;
 /**
- * @tsplus pipeable fncts.Datum foldRight
+ * @tsplus fluent fncts.Datum isReplete
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): (self: Datum<A>) => B;
+export declare function isReplete<A>(self: Datum<A>): self is Replete<A>;
 /**
- * @tsplus pipeable fncts.Datum getOrElse
+ * @tsplus pipeable fncts.Datum map
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function getOrElse<B>(b: Lazy<B>): <A>(self: Datum<A>) => A | B;
+export declare function map<A, B>(f: (a: A) => B): (self: Datum<A>) => Datum<B>;
 /**
  * @tsplus pipeable fncts.Datum match
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -140,11 +117,6 @@ export declare function match<A, B, C, D, E>(cases: {
  * @tsplus location "@fncts/base/data/Datum/api"
  */
 export declare function match2<A, B, C>(onEmpty: (isLoading: boolean) => B, onValue: (a: A, isLoading: boolean) => C): (self: Datum<A>) => B | C;
-/**
- * @tsplus pipeable fncts.Datum map
- * @tsplus location "@fncts/base/data/Datum/api"
- */
-export declare function map<A, B>(f: (a: A) => B): (self: Datum<A>) => Datum<B>;
 /**
  * @tsplus pipeable fncts.Datum orElse
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -161,6 +133,29 @@ export declare function partition<A>(p: Predicate<A>): (self: Datum<A>) => [Datu
  * @tsplus location "@fncts/base/data/Datum/api"
  */
 export declare function partitionMap<A, B, C>(f: (a: A) => Either<B, C>): (self: Datum<A>) => [Datum<B>, Datum<C>];
+/**
+ * @tsplus static fncts.DatumOps pending
+ * @tsplus static fncts.Datum.PendingOps __call
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function pending<A = never>(): Datum<A>;
+/**
+ * @tsplus static fncts.DatumOps refresh
+ * @tsplus static fncts.Datum.RefreshOps __call
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function refresh<A>(value: A): Datum<A>;
+/**
+ * @tsplus static fncts.DatumOps replete
+ * @tsplus static fncts.Datum.RepleteOps __call
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function replete<A>(value: A): Datum<A>;
+/**
+ * @tsplus pipeable fncts.Datum some
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function some<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
 /**
  * @tsplus getter fncts.Datum toPending
  * @tsplus location "@fncts/base/data/Datum/api"
@@ -175,7 +170,12 @@ export declare function toReplete<A>(self: Datum<A>): Datum<A>;
  * @tsplus getter fncts.Datum traverse
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function _traverse<A>(self: Datum<A>): <G extends 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) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Datum<B>>;
+export declare function traverse_<A>(self: Datum<A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Datum<B>>;
+/**
+ * @tsplus getter fncts.Datum value
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function value<A>(self: Datum<A>): A | undefined;
 export declare const traverse: P.Traversable<DatumF>["traverse"];
 /**
  * @tsplus pipeable fncts.Datum zip

package/data/Datum.d.ts

@@ -0,0 +1,3 @@
+export * from "./Datum/api.js";
+export * from "./Datum/definition.js";
+export * from "./Datum/instances.js";

package/data/DatumEither/api.d.ts

@@ -9,10 +9,27 @@ import { Zipped } from "@fncts/base/data/Zipped";
 import type { DatumEitherF } from "@fncts/base/data/DatumEither/definition";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus static fncts.DatumEitherOps initial
+ * @tsplus pipeable fncts.DatumEither bimap
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function initial<E = never, A = never>(): DatumEither<E, A>;
+export declare const bimap: <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E1, B>;
+/**
+ * @tsplus pipeable fncts.DatumEither exists
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+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 pipeable fncts.DatumEither filter
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+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 pipeable fncts.DatumEither filterMap
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
 /**
  * @tsplus static fncts.DatumEitherOps pending
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -38,28 +55,6 @@ export declare function repleteLeft<E, A = never>(e: E): DatumEither<E, A>;
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
 export declare function repleteRight<E = never, A = never>(a: A): DatumEither<E, A>;
-/**
- * @tsplus pipeable fncts.DatumEither bimap
- * @tsplus location "@fncts/base/data/DatumEither/api"
- */
-export declare const bimap: <E, A, E1, B>(f: (e: E) => E1, g: (a: A) => B) => (self: DatumEither<E, A>) => DatumEither<E1, B>;
-/**
- * @tsplus pipeable fncts.DatumEither exists
- * @tsplus location "@fncts/base/data/DatumEither/api"
- */
-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 pipeable fncts.DatumEither filter
- * @tsplus location "@fncts/base/data/DatumEither/api"
- */
-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 pipeable fncts.DatumEither filterMap
- * @tsplus location "@fncts/base/data/DatumEither/api"
- */
-export declare function filterMap<A, B>(f: (a: A) => Maybe<B>): <E>(self: DatumEither<E, A>) => DatumEither<E, B>;
 /**
  * @tsplus pipeable fncts.DatumEither flatMap
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -85,6 +80,11 @@ export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: D
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
 export declare function getOrElse<E, B, C>(onEmpty: () => B, onLeft: (e: E) => C): <A>(self: DatumEither<E, A>) => A | B | C;
+/**
+ * @tsplus static fncts.DatumEitherOps initial
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function initial<E = never, A = never>(): DatumEither<E, A>;
 /**
  * @tsplus pipeable fncts.DatumEither map
  * @tsplus location "@fncts/base/data/DatumEither/api"
@@ -157,7 +157,7 @@ export declare const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E
  * @tsplus getter fncts.DatumEither traverse
  * @tsplus location "@fncts/base/data/DatumEither/api"
  */
-export declare function _traverse<E, A>(self: DatumEither<E, A>): <G extends 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) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, DatumEither<E, B>>;
+export declare function traverse_<E, A>(self: DatumEither<E, A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, DatumEither<E, B>>;
 export declare const traverse: P.Traversable<DatumEitherF>["traverse"];
 /**
  * @tsplus pipeable fncts.DatumEither zipWith

package/data/Either/api.d.ts

@@ -2,8 +2,8 @@ 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 { Zipped } from "@fncts/base/data/Zipped";
 import type * as P from "../../typeclass.js";
 import type { EitherF } from "./definition.js";
 import { Left, Right } from "./definition.js";
@@ -43,30 +43,30 @@ export declare function flatMap<A, E2, B>(f: (a: A) => Either<E2, B>): <E1>(self
  */
 export declare function foldLeft<A, B>(b: B, f: (b: B, a: A) => B): <E>(self: Either<E, A>) => B;
 /**
- * @tsplus pipeable fncts.Either foldRight
+ * @tsplus pipeable fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: Either<E, A>) => B;
+export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: Either<E, A>) => M;
 /**
- * @tsplus pipeable fncts.Either foldMap
+ * @tsplus pipeable fncts.Either foldRight
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMap<A, M>(f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): <E>(self: Either<E, A>) => M;
+export declare function foldRight<A, B>(b: B, f: (a: A, b: B) => B): <E>(self: Either<E, A>) => B;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare function getLeft<E, A>(self: Either<E, A>): Maybe<E>;
 /**
- * @tsplus getter fncts.Either getRight
+ * @tsplus pipeable fncts.Either getOrElse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
+export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: Either<E, A>) => A | B;
 /**
- * @tsplus pipeable fncts.Either getOrElse
+ * @tsplus getter fncts.Either getRight
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function getOrElse<E, B>(orElse: (e: E) => B): <A>(self: Either<E, A>) => A | B;
+export declare function getRight<E, A>(self: Either<E, A>): Maybe<A>;
 /**
  * @tsplus static fncts.EitherOps isEither
  * @tsplus location "@fncts/base/data/Either/api"
@@ -114,42 +114,42 @@ export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
  * @tsplus getter fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function _traverse<E, A>(self: Either<E, A>): <G extends 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) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>>;
-export declare const traverse_: P.Traversable<EitherF>["traverse"];
-/**
- * @tsplus pipeable fncts.Either zipWith
- * @tsplus location "@fncts/base/data/Either/api"
- */
-export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;
+export declare function traverse_<E, A>(self: Either<E, A>): <G extends HKT, GC = HKT.None>(G: P.Applicative<G, GC>) => <K, Q, W, X, I, S, R, E1, B>(f: (a: A) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, B>) => HKT.Kind<G, GC, K, Q, W, X, I, S, R, E1, Either<E, B>>;
+export declare const traverse: P.Traversable<EitherF>["traverse"];
 /**
- * @tsplus pipeable fncts.Either zip
+ * @tsplus pipeable fncts.Either filter
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: Either<E, A>) => Either<E | E1, Zipped.Make<A, B>>;
+export declare function filter<E, A>(f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: Either<E, A>) => Either<E, A>;
 /**
  * @tsplus pipeable fncts.Either filterMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
 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 pipeable fncts.Either filter
+ * @tsplus pipeable fncts.Either partition
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function filter<E, A>(f: Predicate<A>, /** @tsplus auto */ M: P.Monoid<E>): (self: 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>];
 /**
  * @tsplus pipeable fncts.Either partitionMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
 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 pipeable fncts.Either partition
+ * @tsplus getter fncts.Either toMaybe
  * @tsplus location "@fncts/base/data/Either/api"
  */
-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 declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
 /**
- * @tsplus getter fncts.Either toMaybe
+ * @tsplus pipeable fncts.Either zip
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function toMaybe<E, A>(self: Either<E, A>): Maybe<A>;
+export declare function zip<E1, B>(that: Either<E1, B>): <E, A>(self: Either<E, A>) => Either<E | E1, Zipped.Make<A, B>>;
+/**
+ * @tsplus pipeable fncts.Either zipWith
+ * @tsplus location "@fncts/base/data/Either/api"
+ */
+export declare function zipWith<A, E2, B, C>(fb: Either<E2, B>, f: (a: A, b: B) => C): <E1>(self: Either<E1, A>) => Either<E1 | E2, C>;
 export * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/constructors.d.ts

@@ -4,18 +4,6 @@ import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import type { Nullable } from "@fncts/base/types";
 import { Either } from "./definition.js";
-/**
- * @tsplus static fncts.EitherOps left
- * @tsplus static fncts.Either.LeftOps __call
- * @tsplus location "@fncts/base/data/Either/constructors"
- */
-export declare function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A>;
-/**
- * @tsplus static fncts.EitherOps right
- * @tsplus static fncts.Either.RightOps __call
- * @tsplus location "@fncts/base/data/Either/constructors"
- */
-export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps fromMaybe
  * @tsplus pipeable fncts.Maybe toEither
@@ -38,6 +26,18 @@ export declare function fromNullableK<E, P extends ReadonlyArray<unknown>, A>(f:
  */
 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 left
+ * @tsplus static fncts.Either.LeftOps __call
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function left<E = never, A = never>(e: E, __tsplusTrace?: string): Either<E, A>;
+/**
+ * @tsplus static fncts.EitherOps right
+ * @tsplus static fncts.Either.RightOps __call
+ * @tsplus location "@fncts/base/data/Either/constructors"
+ */
+export declare function right<E = never, A = never>(a: A, __tsplusTrace?: string): Either<E, A>;
 /**
  * @tsplus static fncts.EitherOps tryCatch
  * @tsplus location "@fncts/base/data/Either/constructors"

package/data/EitherT/api.d.ts

@@ -4,30 +4,30 @@ import { Lazy } from "@fncts/base/data/function/definition";
 import type { EitherT } from "./definition.js";
 import type * as P from "@fncts/base/typeclass";
 /**
- * @tsplus static fncts.EitherTOps __call
+ * @tsplus static fncts.EitherTOps bimap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function make<F extends HKT, FC, K, Q, W, X, I, S, R, FE, E, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>): EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+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: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, B>>);
 /**
- * @tsplus static fncts.EitherTOps right
+ * @tsplus static fncts.EitherTOps flatMap
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function right<F extends HKT, FC>(F: P.Pointed<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(a: A) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+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) => 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", FE, FE1>, Either<E1, B>>) => (<E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<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", [FE, FE1]>, E | E1, B>);
 /**
  * @tsplus static fncts.EitherTOps left
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
 export declare function left<F extends HKT, FC>(F: P.Pointed<F, FC>): <K, Q, W, X, I, S, R, FE, E, A = never>(e: E) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
 /**
- * @tsplus static fncts.EitherTOps rightF
+ * @tsplus static fncts.EitherTOps leftF
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function rightF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
 /**
- * @tsplus static fncts.EitherTOps leftF
+ * @tsplus static fncts.EitherTOps __call
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-export declare function leftF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, E>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
+export declare function make<F extends HKT, FC, K, Q, W, X, I, S, R, FE, E, A>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>): EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
 /**
  * @tsplus static fncts.EitherTOps map
  * @tsplus location "@fncts/base/data/EitherT/api"
@@ -39,22 +39,22 @@ export declare function map<F extends HKT, FC>(F: P.Functor<F, FC>): <A, B>(f: (
  */
 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: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, A>>);
 /**
- * @tsplus static fncts.EitherTOps bimap
+ * @tsplus static fncts.EitherTOps orElse
  * @tsplus location "@fncts/base/data/EitherT/api"
  */
-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: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E, A>>) => HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, Either<E1, 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>>;
 /**
- * @tsplus static fncts.EitherTOps flatMap
+ * @tsplus static fncts.EitherTOps right
  * @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, A, K1, Q1, W1, X1, I1, S1, R1, FE1, E1, B>(f: (a: 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", FE, FE1>, Either<E1, B>>) => (<E>(self: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<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", [FE, FE1]>, E | E1, B>);
+export declare function right<F extends HKT, FC>(F: P.Pointed<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(a: A) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
 /**
- * @tsplus static fncts.EitherTOps zipWith
+ * @tsplus static fncts.EitherTOps rightF
  * @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, 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>>;
+export declare function rightF<F extends HKT, FC>(F: P.Functor<F, FC>): <K, Q, W, X, I, S, R, FE, E = never, A = never>(self: HKT.Kind<F, FC, K, Q, W, X, I, S, R, FE, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>;
 /**
- * @tsplus static fncts.EitherTOps orElse
+ * @tsplus static fncts.EitherTOps zipWith
  * @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, 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>>;
+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>>;

package/data/Environment/api.d.ts

@@ -5,8 +5,10 @@ import { Maybe } from "@fncts/base/data/Maybe/definition";
  * @tsplus pipeable fncts.Environment add
  * @tsplus location "@fncts/base/data/Environment/api"
  */
-export declare function add<H extends S, S = H>(service: H, tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
-export declare function add<H extends S, S = H, I = S>(service: H, tag: Tag<S, I>): <R>(self: Environment<R>) => Environment<R | I>;
+export declare function add<H extends S, S = H>(service: H, 
+/** @tsplus auto */ tag: Tag<S>): <R>(self: Environment<R>) => Environment<R | S>;
+export declare function add<H extends S, S = H, I = S>(service: H, 
+/** @tsplus auto */ tag: Tag<S, I>): <R>(self: Environment<R>) => Environment<R | I>;
 /**
  * @tsplus static fncts.EnvironmentOps empty
  * @tsplus location "@fncts/base/data/Environment/api"