@fncts/base 0.0.12 → 0.0.15

package/data/Const/definition.d.ts

@@ -2,12 +2,12 @@ import { HKT } from "@fncts/typelevel/HKT";
 /**
  * @tsplus type fncts.ConstF
  */
-export interface ConstF extends Const<any, any> {
-}
-/**
- * @tsplus type fncts.ConstF
- */
-export interface Const1F<E> extends Const1<E, any> {
+export interface ConstF extends HKT {
+    type: Const<this["E"], this["A"]>;
+    variance: {
+        E: "_";
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.Const
@@ -15,15 +15,7 @@ export interface Const1F<E> extends Const1<E, any> {
  */
 export declare class Const<E, A> {
     readonly getConst: E;
-    readonly [HKT.F]: ConstF;
-    readonly [HKT.E]: () => E;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Const<HKT._E<this>, HKT._A<this>>;
+    readonly _E: () => E;
+    readonly _A: () => A;
     constructor(getConst: E);
 }
-export interface Const1<E, A> {
-    readonly [HKT.F]: ConstF;
-    readonly [HKT.E]: () => E;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Const<E, HKT._A<this>>;
-}

package/data/Const/instances.d.ts

@@ -1,12 +1,13 @@
+import { HKT } from "@fncts/typelevel/HKT";
 import type * as P from "../../typeclass.js";
-import type { Const1F } from "@fncts/base/data/Const/definition";
+import type { ConstF } from "@fncts/base/data/Const/definition";
 /**
  * @tsplus static fncts.ConstOps getApply
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<Const1F<E>>;
+export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<ConstF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;
 /**
  * @tsplus static fncts.ConstOps getApplicative
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<Const1F<E>>;
+export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>>;

package/data/Datum/api.d.ts

@@ -0,0 +1,188 @@
+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 { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+import type { DatumF } from "@fncts/base/data/Datum/definition";
+import type * as P from "@fncts/base/typeclass";
+import type { Eq } from "@fncts/base/typeclass/Eq";
+import { Initial, Pending, Refresh, Replete } from "@fncts/base/data/Datum/definition";
+import { Zipped } from "@fncts/base/data/Zipped";
+/**
+ * @tsplus static fncts.DatumOps initial
+ * @tsplus static fncts.Datum.InitialOps __call
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function initial<A = never>(): Datum<A>;
+/**
+ * @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 getter fncts.Datum value
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function left<E, A>(self: Datum<A>): A | undefined;
+/**
+ * @tsplus fluent fncts.Datum isInitial
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function isInitial<A>(self: Datum<A>): self is Initial;
+/**
+ * @tsplus fluent fncts.Datum isPending
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function isPending<A>(self: Datum<A>): self is Pending;
+/**
+ * @tsplus fluent fncts.Datum isRefresh
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function isRefresh<A>(self: Datum<A>): self is Refresh<A>;
+/**
+ * @tsplus fluent fncts.Datum isReplete
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function isReplete<A>(self: Datum<A>): self is Replete<A>;
+/**
+ * @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 location "@fncts/base/data/Datum/api"
+ */
+export declare function isNonEmpty<A>(self: Datum<A>): self is Refresh<A> | Replete<A>;
+/**
+ * @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 fluent 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;
+/**
+ * @tsplus fluent fncts.Datum exists
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function exists<A, B extends A>(self: Datum<A>, p: Refinement<A, B>): self is Datum<B>;
+export declare function exists<A>(self: Datum<A>, p: Predicate<A>): boolean;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent fncts.Datum getOrElse
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function getOrElse<A, B>(self: Datum<A>, b: Lazy<B>): A | B;
+/**
+ * @tsplus fluent fncts.Datum match
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function match<A, B, C, D, E>(self: Datum<A>, cases: {
+    Initial: () => B;
+    Pending: () => C;
+    Refresh: (a: A) => D;
+    Replete: (a: A) => E;
+}): B | C | D | E;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>];
+/**
+ * @tsplus fluent 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>];
+/**
+ * @tsplus getter fncts.Datum toPending
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function toPending<A>(self: Datum<A>): Datum<A>;
+/**
+ * @tsplus getter fncts.Datum toReplete
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare function toReplete<A>(self: Datum<A>): Datum<A>;
+/**
+ * @tsplus fluent fncts.Datum traverse
+ * @tsplus location "@fncts/base/data/Datum/api"
+ */
+export declare const traverse: P.Traversable<DatumF>["traverse"];
+/**
+ * @tsplus fluent 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>>;
+/**
+ * @tsplus fluent 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>;

package/data/Datum/definition.d.ts

@@ -0,0 +1,75 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/typeclass/Equatable";
+export declare const enum DatumTag {
+    Initial = "Initial",
+    Pending = "Pending",
+    Refresh = "Refresh",
+    Replete = "Replete"
+}
+export declare const DatumTypeId: unique symbol;
+export declare type DatumTypeId = typeof DatumTypeId;
+export interface DatumF extends HKT {
+    type: Datum<this["A"]>;
+    variance: {
+        A: "+";
+    };
+}
+/**
+ * @tsplus type fncts.Datum
+ */
+export declare type Datum<A> = Initial | Pending | Refresh<A> | Replete<A>;
+/**
+ * @tsplus type fncts.DatumOps
+ */
+export interface DatumOps {
+}
+export declare const Datum: DatumOps;
+/**
+ * @tsplus type fncts.Datum.Initial
+ * @tsplus companion fncts.Datum.InitialOps
+ */
+export declare class Initial implements Hashable, Equatable {
+    readonly _tag = DatumTag.Initial;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.Datum.Pending
+ * @tsplus companion fncts.Datum.PendingOps
+ */
+export declare class Pending implements Hashable, Equatable {
+    readonly _typeId: DatumTypeId;
+    readonly _tag = DatumTag.Pending;
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.Datum.Refresh
+ * @tsplus companion fncts.Datum.RefreshOps
+ */
+export declare class Refresh<A> implements Hashable, Equatable {
+    readonly value: A;
+    readonly _typeId: DatumTypeId;
+    readonly _tag = DatumTag.Refresh;
+    constructor(value: A);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus type fncts.Datum.Replete
+ * @tsplus companion fncts.Datum.RepleteOps
+ */
+export declare class Replete<A> implements Hashable, Equatable {
+    readonly value: A;
+    readonly _typeId: DatumTypeId;
+    readonly _tag = DatumTag.Replete;
+    constructor(value: A);
+    get [Symbol.hash](): number;
+    [Symbol.equals](that: unknown): boolean;
+}
+/**
+ * @tsplus static fncts.DatumOps is
+ * @tsplus location "@fncts/base/data/Datum/definition"
+ */
+export declare function isDatum(u: unknown): u is Datum<unknown>;

package/data/Datum/instances.d.ts

@@ -0,0 +1,32 @@
+import type { DatumF } from "./definition.js";
+import type * as P from "@fncts/base/typeclass";
+/**
+ * @tsplus static fncts.DatumOps Functor
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Datum/instances"
+ */
+export declare const Functor: P.Functor<DatumF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.DatumOps Semimonoidal
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Datum/instances"
+ */
+export declare const Semimonoidal: P.Semimonoidal<DatumF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.DatumOps Apply
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Datum/instances"
+ */
+export declare const Apply: P.Apply<DatumF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.DatumOps Applicative
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Datum/instances"
+ */
+export declare const Applicative: P.Applicative<DatumF, import("@fncts/typelevel/HKT.js").HKT.None>;
+/**
+ * @tsplus static fncts.DatumOps Monad
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Datum/instances"
+ */
+export declare const Monad: P.Monad<DatumF, import("@fncts/typelevel/HKT.js").HKT.None>;

package/data/DatumEither/api.d.ts

@@ -0,0 +1,169 @@
+import { DatumEither } from "@fncts/base/data/DatumEither/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 { Either } from "@fncts/base/data/Either/definition";
+import { Lazy } from "@fncts/base/data/function/definition";
+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 location "@fncts/base/data/DatumEither/api"
+ */
+export declare function initial<E = never, A = never>(): DatumEither<E, A>;
+/**
+ * @tsplus static fncts.DatumEitherOps pending
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function pending<E = never, A = never>(): DatumEither<E, A>;
+/**
+ * @tsplus static fncts.DatumEitherOps refreshLeft
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function refreshLeft<E, A = never>(e: E): DatumEither<E, A>;
+/**
+ * @tsplus static fncts.DatumEitherOps refreshRight
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function refreshRight<E = never, A = never>(a: A): DatumEither<E, A>;
+/**
+ * @tsplus static fncts.DatumEitherOps repleteLeft
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function repleteLeft<E, A = never>(e: E): DatumEither<E, A>;
+/**
+ * @tsplus static fncts.DatumEitherOps repleteRight
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare function repleteRight<E = never, A = never>(a: A): DatumEither<E, A>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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;
+/**
+ * @tsplus fluent 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: {
+    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;
+/**
+ * @tsplus fluent 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: {
+    Initial: () => B;
+    Pending: () => C;
+    Refresh: (value: Either<E, A>) => D;
+    Replete: (value: Either<E, A>) => F;
+}) => B | C | D | F;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>];
+/**
+ * @tsplus fluent 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>];
+/**
+ * @tsplus getter fncts.DatumEither toPending
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare const toPending: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A>;
+/**
+ * @tsplus getter fncts.DatumEither toReplete
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare const toReplete: <E, A>(self: DatumEither<E, A>) => DatumEither<E, A>;
+/**
+ * @tsplus fluent fncts.DatumEither traverse
+ * @tsplus location "@fncts/base/data/DatumEither/api"
+ */
+export declare const traverse: P.Traversable<DatumEitherF>["traverse"];
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>>;

package/data/DatumEither/definition.d.ts

@@ -0,0 +1,21 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import { Datum } from "@fncts/base/data/Datum/definition";
+import { Either } from "@fncts/base/data/Either/definition";
+export interface DatumEitherF extends HKT {
+    type: DatumEither<this["E"], this["A"]>;
+    variance: {
+        E: "+";
+        A: "+";
+    };
+}
+/**
+ * @tsplus type fncts.DatumEither
+ * @tsplus no-inherit fncts.Datum
+ */
+export declare type DatumEither<E, A> = Datum<Either<E, A>>;
+/**
+ * @tsplus type fncts.DatumEitherOps
+ */
+export interface DatumEitherOps {
+}
+export declare const DatumEither: DatumEitherOps;

package/data/DecodeError/definition.d.ts

@@ -139,3 +139,9 @@ export declare class UnionError extends DecodeError {
     constructor(label: string, errors: Vector<DecodeError>);
     render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
 }
+export declare class EmptyError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "EmptyError";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}

package/data/DecodeError/instances.d.ts

@@ -0,0 +1 @@
+export {};

package/data/DecodeError.d.ts

@@ -1 +1,2 @@
 export * from "./DecodeError/definition.js";
+export * from "./DecodeError/instances.js";

package/data/Decoder/definition.d.ts

@@ -3,7 +3,11 @@ import { These } from "@fncts/base/data/These";
 import type { DecodeError } from "@fncts/base/data/DecodeError";
 export declare const DecoderTypeId: unique symbol;
 export declare type DecoderTypeId = typeof DecoderTypeId;
-export interface DecoderF extends Decoder<any> {
+export interface DecoderF extends HKT {
+    type: Decoder<this["A"]>;
+    variance: {
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.Decoder
@@ -13,9 +17,7 @@ export declare class Decoder<A> {
     readonly decode: (input: unknown) => These<DecodeError, A>;
     readonly label: string;
     readonly _typeId: DecoderTypeId;
-    readonly [HKT.F]: DecoderF;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Decoder<HKT._A<this>>;
+    readonly _A: () => A;
     constructor(decode: (input: unknown) => These<DecodeError, A>, label: string);
 }
 /**

package/data/Either/api.d.ts

@@ -1,6 +1,7 @@
 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 { 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";
@@ -118,7 +119,16 @@ export declare function swap<E, A>(self: Either<E, A>): Either<A, E>;
  * @tsplus location "@fncts/base/data/Either/api"
  */
 export declare const traverse_: P.Traversable<EitherF>["traverse"];
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>>;
 /**
  * @tsplus fluent fncts.Either filterMap
  * @tsplus location "@fncts/base/data/Either/api"

package/data/Either/definition.d.ts

@@ -5,9 +5,12 @@ export declare const enum EitherTag {
 }
 export declare const EitherTypeId: unique symbol;
 export declare type EitherTypeId = typeof EitherTypeId;
-export interface EitherF extends Either<any, any> {
-}
-export interface Either1F<E> extends Either1<E, any> {
+export interface EitherF extends HKT {
+    type: Either<this["E"], this["A"]>;
+    variance: {
+        E: "+";
+        A: "+";
+    };
 }
 /**
  * @tsplus type fncts.Either
@@ -15,17 +18,8 @@ export interface Either1F<E> extends Either1<E, any> {
  */
 export declare class Either<E, A> {
     readonly _typeId: EitherTypeId;
-    readonly [HKT.F]: EitherF;
-    readonly [HKT.E]: () => E;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Either<HKT._E<this>, HKT._A<this>>;
-}
-export interface Either1<E, A> {
-    readonly _typeId: EitherTypeId;
-    readonly [HKT.F]: EitherF;
-    readonly [HKT.E]: () => E;
-    readonly [HKT.A]: () => A;
-    readonly [HKT.T]: Either<E, HKT._A<this>>;
+    readonly _E: () => E;
+    readonly _A: () => A;
 }
 /**
  * @tsplus type fncts.Either.Left