@fncts/base 0.0.3 → 0.0.4

package/data/Branded.d.ts

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

package/data/Cause/api.d.ts

@@ -6,7 +6,7 @@ import { Either } from "@fncts/base/data/Either/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
 import { FiberId } from "@fncts/base/data/FiberId/definition";
-import { Both, Cause, Fail, Halt, Then } from "./definition.js";
+import { Both, Cause, Fail, Halt, Interrupt, Then } from "./definition.js";
 /**
  * @tsplus fluent fncts.Cause as
  * @tsplus location "@fncts/base/data/Cause/api"
@@ -181,6 +181,12 @@ export declare function isHalt<E>(self: Cause<E>): self is Halt;
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function isThen<E>(self: Cause<E>): self is Then<E>;
+/**
+ * A type-guard matching `Interrupt`
+ * @tsplus fluent fncts.Cause isInterrupt
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isInterrupt<E>(self: Cause<E>): self is Interrupt;
 /**
  * A type-guard matching `Traced`
  * @tsplus getter fncts.Cause isTraced

package/data/Const/api.d.ts

@@ -1,4 +1,4 @@
-import type { Const } from "./definition.js";
+import { Const } from "./definition.js";
 /**
  * @tsplus fluent fncts.Const map
  * @tsplus location "@fncts/base/data/Const/api"

package/data/Const/definition.d.ts

@@ -1,12 +1,28 @@
 /**
- * @tsplus type fncts.Const
+ * @tsplus type fncts.ConstF
  */
-export declare type Const<E, A> = E & {
-    readonly _A: A;
-};
+export interface ConstF extends Const<any, any> {
+}
 /**
- * @tsplus type fncts.ConstOps
+ * @tsplus type fncts.ConstF
  */
-export interface ConstOps {
+export interface Const1F<E> extends Const1<E, any> {
+}
+/**
+ * @tsplus type fncts.Const
+ * @tsplus companion fncts.ConstOps
+ */
+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>>;
+    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>>;
 }
-export declare const Const: ConstOps;

package/data/Const/instances.d.ts

@@ -1,20 +1,12 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Const } from "@fncts/base/data/Const/definition";
-import * as P from "../../typeclass.js";
-export interface ConstF extends HKT {
-    readonly type: Const<this["E"], this["A"]>;
-    readonly variance: {
-        E: "_";
-        A: "_";
-    };
-}
+import type * as P from "../../typeclass.js";
+import type { Const1F } 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<ConstF, HKT.Fix<"E", E>>;
+export declare function getApply<E>(S: P.Semigroup<E>): P.Apply<Const1F<E>>;
 /**
  * @tsplus static fncts.ConstOps getApplicative
  * @tsplus location "@fncts/base/data/Const/instances"
  */
-export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<ConstF, HKT.Fix<"E", E>>;
+export declare function getApplicative<E>(M: P.Monoid<E>): P.Applicative<Const1F<E>>;

package/data/DecodeError/definition.d.ts

@@ -0,0 +1,141 @@
+import { Eval } from "@fncts/base/control/Eval/definition";
+import { RoseTree } from "@fncts/base/collection/immutable/RoseTree";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+export declare const DecodeErrorTypeId: unique symbol;
+export declare type DecodeErrorTypeId = typeof DecodeErrorTypeId;
+export declare abstract class DecodeError {
+    readonly _typeId: DecodeErrorTypeId;
+    abstract render: Eval<RoseTree<string>>;
+}
+export declare class RequiredKeyError extends DecodeError {
+    readonly key: string;
+    readonly error: DecodeError;
+    readonly _tag = "RequiredKey";
+    constructor(key: string, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class OptionalKeyError extends DecodeError {
+    readonly key: PropertyKey;
+    readonly error: DecodeError;
+    readonly _tag = "OptionalKey";
+    constructor(key: PropertyKey, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class RequiredIndexError<I, E extends DecodeError> extends DecodeError {
+    readonly index: I;
+    readonly error: E;
+    readonly _tag = "RequiredIndex";
+    constructor(index: I, error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class OptionalIndexError<I, E extends DecodeError> extends DecodeError {
+    readonly index: I;
+    readonly error: E;
+    readonly _tag = "RequiredIndex";
+    constructor(index: I, error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class LazyError<E extends DecodeError> extends DecodeError {
+    readonly error: E;
+    readonly _tag = "Lazy";
+    constructor(error: E);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MemberError extends DecodeError {
+    readonly label: string;
+    readonly error: DecodeError;
+    readonly _tag = "Member";
+    constructor(label: string, error: DecodeError);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class CompoundError<E extends DecodeError> extends DecodeError {
+    readonly name: string;
+    readonly errors: Vector<E>;
+    readonly _tag = "Compound";
+    constructor(name: string, errors: Vector<E>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class CompositionError<E extends DecodeError> extends DecodeError {
+    readonly errors: Vector<E>;
+    readonly _tag = "Composition";
+    constructor(errors: Vector<E>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class StringError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "String";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class NumberError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "Number";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class NaNError extends DecodeError {
+    readonly _tag = "NaN";
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class InfinityError extends DecodeError {
+    readonly _tag = "Infinity";
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class BooleanError extends DecodeError {
+    readonly actual: unknown;
+    readonly _tag = "Boolean";
+    constructor(actual: unknown);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class PrimitiveError extends DecodeError {
+    readonly actual: unknown;
+    readonly name: string;
+    readonly _tag = "Primitive";
+    constructor(actual: unknown, name: string);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class LiteralError<A extends string | number | boolean> extends DecodeError {
+    readonly actual: unknown;
+    readonly literals: Vector<A>;
+    readonly _tag = "Literal";
+    constructor(actual: unknown, literals: Vector<A>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnexpectedKeysError extends DecodeError {
+    readonly keys: Vector<string>;
+    readonly _tag = "UnexpectedKeys";
+    constructor(keys: Vector<string>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnexpectedIndicesError extends DecodeError {
+    readonly indices: Vector<number>;
+    readonly _tag = "UnexpectedIndices";
+    constructor(indices: Vector<number>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MissingKeyError extends DecodeError {
+    readonly key: PropertyKey;
+    readonly _tag = "MissingKeys";
+    constructor(key: PropertyKey);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class MissingIndicesError extends DecodeError {
+    readonly keys: Vector<PropertyKey>;
+    readonly _tag = "MissingIndices";
+    constructor(keys: Vector<PropertyKey>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class BrandedError extends DecodeError {
+    readonly name: string;
+    readonly brands: Vector<string>;
+    readonly _tag = "BrandedError";
+    constructor(name: string, brands: Vector<string>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}
+export declare class UnionError extends DecodeError {
+    readonly label: string;
+    readonly errors: Vector<DecodeError>;
+    readonly _tag = "UnionError";
+    constructor(label: string, errors: Vector<DecodeError>);
+    render: import("../../control/Eval").Eval<import("../../collection/immutable/RoseTree").RoseTree<string>>;
+}

package/data/DecodeError.d.ts

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

package/data/Decoder/api.d.ts

@@ -0,0 +1,65 @@
+import { These } from "@fncts/base/data/These";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Check } from "@fncts/typelevel/Check";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+import { Decoder } from "@fncts/base/data/Decoder/definition";
+/**
+ * @tsplus fluent fncts.Decoder __call
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function decode<I, E, A>(self: Decoder<A>, input: unknown): These<DecodeError, A>;
+export declare function fromGuard<A>(guard: Guard<A>, onFalse: (i: unknown) => DecodeError, label: string): Decoder<A>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const string: Decoder<string>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const number: Decoder<number>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const boolean: Decoder<boolean>;
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const record: Decoder<{}>;
+/**
+ * @tsplus derive fncts.Decoder lazy
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveLazy<A>(f: (_: Decoder<A>) => Decoder<A>): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder<_> 20
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveLiteral<A extends string | number | boolean>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder<|> 30
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveUnion<A extends ReadonlyArray<unknown>>(...elements: {
+    [K in keyof A]: Decoder<A[K]>;
+}): Decoder<A[number]>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [k in RequiredKeys<A>]: Decoder<A[k]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [] : [
+        optionalFields: {
+            [k in OptionalKeys<A>]: Decoder<NonNullable<A[k]>>;
+        }
+    ])
+] : never): Decoder<A>;

package/data/Decoder/definition.d.ts

@@ -0,0 +1,24 @@
+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> {
+}
+/**
+ * @tsplus type fncts.Decoder
+ * @tsplus companion fncts.DecoderOps
+ */
+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>>;
+    constructor(decode: (input: unknown) => These<DecodeError, A>, label: string);
+}
+/**
+ * @tsplus static fncts.DecoderOps __call
+ * @tsplus location "@fncts/base/data/Decoder/definition"
+ */
+export declare function makeDecoder<A>(decode: (input: unknown) => These<DecodeError, A>, label: string): Decoder<A>;

package/data/Decoder.d.ts

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

package/data/Duration/api.d.ts

@@ -1,45 +1,44 @@
 import { Duration } from "@fncts/base/data/Duration/definition";
-import type { IsInt } from "@fncts/base/types";
 /**
  * @tsplus getter fncts.Number milliseconds
  * @tsplus static fncts.DurationOps milliseconds
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function milliseconds<N extends number>(self: IsInt<N>): Duration;
+export declare function milliseconds(self: number): Duration;
 /**
  * @tsplus getter fncts.Number seconds
  * @tsplus static fncts.DurationOps seconds
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function seconds<N extends number>(self: IsInt<N>): Duration;
+export declare function seconds(self: number): Duration;
 /**
  * @tsplus getter fncts.Number minutes
  * @tsplus static fncts.DurationOps minutes
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function minutes<N extends number>(self: IsInt<N>): Duration;
+export declare function minutes(self: number): Duration;
 /**
  * @tsplus getter fncts.Number hours
  * @tsplus static fncts.DurationOps hours
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function hours<N extends number>(self: IsInt<N>): Duration;
+export declare function hours(self: number): Duration;
 /**
  * @tsplus getter fncts.Number days
  * @tsplus static fncts.DurationOps days
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function days<N extends number>(self: IsInt<N>): Duration;
+export declare function days(self: number): Duration;
 /**
  * @tsplus operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function mult<N extends number>(self: Duration, multiplicand: IsInt<N>): import("./definition").Duration;
+export declare function mult(self: Duration, multiplicand: number): import("./definition").Duration;
 /**
  * @tsplus operator fncts.Duration *
  * @tsplus location "@fncts/base/data/Duration/api"
  */
-export declare function multInverted<N extends number>(multiplicand: IsInt<N>, self: Duration): import("./definition").Duration;
+export declare function multInverted(multiplicand: number, self: Duration): import("./definition").Duration;
 /**
  * @tsplus operator fncts.Duration +
  * @tsplus location "@fncts/base/data/Duration/api"
@@ -50,3 +49,8 @@ export declare function sum(self: Duration, that: Duration): Duration;
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function difference(self: Duration, that: Duration): Duration;
+/**
+ * @tsplus static fncts.DurationOps fromInterval
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare function fromInterval(start: number, end: number): Duration;

package/data/Either/api.d.ts

@@ -1,8 +1,9 @@
 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 { Predicate } from "@fncts/base/data/Predicate/definition";
 import type * as P from "../../typeclass.js";
-import type { EitherF } from "./instances.js";
+import type { EitherF } from "./definition.js";
 import { Left, Right } from "./definition.js";
 /**
  * @tsplus fluent fncts.Either ap
@@ -45,14 +46,10 @@ export declare function foldLeft_<E, A, B>(self: Either<E, A>, b: B, f: (b: B, a
  */
 export declare function foldRight_<E, A, B>(self: Either<E, A>, b: B, f: (a: A, b: B) => B): B;
 /**
- * @constrained
- */
-export declare function foldMap_<M>(M: P.Monoid<M>): <E, A>(self: import("./definition.js").Either<E, A>, f: (a: A) => M) => M;
-/**
- * @tsplus getter fncts.Either foldMap
+ * @tsplus fluent fncts.Either foldMap
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare function foldMapSelf<E, A>(self: Either<E, A>): <M>(M: P.Monoid<M>) => (f: (a: A) => M) => M;
+export declare function foldMap_<E, A, M>(self: Either<E, A>, f: (a: A) => M, /** @tsplus auto */ M: P.Monoid<M>): M;
 /**
  * @tsplus getter fncts.Either getLeft
  * @tsplus location "@fncts/base/data/Either/api"
@@ -105,24 +102,39 @@ export declare function merge<E, A>(self: Either<E, A>): E | A;
  * @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 const sequence: P.sequence<EitherF>;
-/**
- * @tsplus getter fncts.Either sequence
- * @tsplus location "@fncts/base/data/Either/api"
- */
-export declare const sequenceSelf: P.sequenceSelf<EitherF>;
 /**
  * @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>;
-export declare const traverse_: P.traverse_<EitherF>;
-export declare const traverse: P.traverse<EitherF>;
 /**
- * @tsplus getter fncts.Either traverse
+ * @tsplus fluent fncts.Either traverse
  * @tsplus location "@fncts/base/data/Either/api"
  */
-export declare const traverseSelf: P.traverseSelf<EitherF>;
+export declare const traverse_: P.Traversable<EitherF>["traverse"];
 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 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>;
+/**
+ * @tsplus fluent 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>;
+/**
+ * @tsplus fluent 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>];
+/**
+ * @tsplus fluent 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 * from "./api/align.js";
 export * from "./api/alignWith.js";

package/data/Either/definition.d.ts

@@ -4,13 +4,34 @@ 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> {
+}
+/**
+ * @tsplus type fncts.Either
+ * @tsplus companion fncts.EitherOps
+ */
+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>>;
+}
 /**
  * @tsplus type fncts.Either.Left
  * @tsplus companion fncts.Either.LeftOps
  */
-export declare class Left<E> {
+export declare class Left<E> extends Either<E, never> {
     readonly left: E;
-    readonly _typeId: EitherTypeId;
     readonly _tag = EitherTag.Left;
     constructor(left: E);
 }
@@ -18,23 +39,19 @@ export declare class Left<E> {
  * @tsplus type fncts.Either.Right
  * @tsplus companion fncts.Either.RightOps
  */
-export declare class Right<A> {
+export declare class Right<A> extends Either<never, A> {
     readonly right: A;
-    readonly _typeId: EitherTypeId;
     readonly _tag = EitherTag.Right;
     constructor(right: A);
 }
-/**
- * @tsplus type fncts.Either
- */
-export declare type Either<E, A> = Left<E> | Right<A>;
-/**
- * @tsplus type fncts.EitherOps
- */
-export interface EitherOps {
-}
-export declare const Either: EitherOps;
 /**
  * @tsplus unify fncts.Either
  */
 export declare function unifyEither<X extends Either<any, any>>(self: X): Either<[X] extends [Either<infer E, any>] ? E : never, [X] extends [Either<any, infer A>] ? A : never>;
+/**
+ * @tsplus fluent fncts.Either concrete
+ * @tsplus static fncts.EitherOps concrete
+ * @tsplus macro remove
+ * @tsplus location "@fncts/base/data/Either/definition"
+ */
+export declare function concrete<E, A>(self: Either<E, A>): asserts self is Left<E> | Right<A>;

package/data/Either/instances.d.ts

@@ -1,21 +1,36 @@
-import { HKT } from "@fncts/typelevel/HKT";
-import { Either } from "@fncts/base/data/Either/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Guard } from "@fncts/base/typeclass/Guard";
+import { Decoder } from "@fncts/base/data/Decoder";
+import type { Either1F, EitherF } from "@fncts/base/data/Either/definition.js";
+import { Either } from "@fncts/base/data/Either/definition";
 import * as P from "../../typeclass.js";
-export interface EitherF extends HKT {
-    readonly type: Either<this["E"], this["A"]>;
-    readonly variance: {
-        E: "+";
-        A: "+";
-    };
-}
+/**
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare const Functor: P.Functor<EitherF>;
 /**
  * @tsplus static fncts.EitherOps getEq
  * @tsplus location "@fncts/base/data/Either/instances"
  */
 export declare function getEq<E, A>(EE: P.Eq<E>, EA: P.Eq<A>): P.Eq<Either<E, A>>;
 /**
- * @tsplus static fncts.EitherOps getEq
+ * @tsplus derive fncts.Eq[fncts.Either]<_> 10
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function deriveEq<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: P.Eq<E>, right: P.Eq<A>] : never): P.Eq<A>;
+/**
+ * @tsplus static fncts.EitherOps getFilterable
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function getFilerable<E>(/** @tsplus auto */ ME: P.Monoid<E>): P.Filterable<Either1F<E>>;
+/**
+ * @tsplus derive fncts.Guard[fncts.Either]<_> 10
+ * @tsplus location "@fncts/base/data/Either/instances"
+ */
+export declare function deriveGuard<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Guard<E>, right: Guard<A>] : never): Guard<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Either]<_> 10
  * @tsplus location "@fncts/base/data/Either/instances"
  */
-export declare function getFilerable<E>(ME: P.Monoid<E>): P.Filterable<EitherF, import("@fncts/typelevel/HKT.js").HKT.Fix<"E", E>>;
+export declare function deriveDecoder<A extends Either<any, any>>(...[left, right]: [A] extends [Either<infer E, infer A>] ? [left: Decoder<E>, right: Decoder<A>] : never): Decoder<A>;

package/data/Environment/api.d.ts

@@ -33,6 +33,11 @@ export declare function make(): Environment<unknown>;
  * @tsplus location "@fncts/base/data/Environment/api"
  */
 export declare function union<R, R1>(self: Environment<R>, that: Environment<R1>): 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 location "@fncts/base/data/Environment/api"

package/data/Identity/api.d.ts

@@ -20,3 +20,14 @@ export declare function pure<A>(a: A): Identity<A>;
  * @tsplus location "@fncts/base/data/Identity/api"
  */
 export declare function zipWith_<A, B, C>(fa: Identity<A>, fb: Identity<B>, f: (a: A, b: B) => C): Identity<C>;
+/**
+ * @tsplus fluent fncts.Identity zip
+ * @tsplus location "@fncts/base/data/Identity/api"
+ */
+export declare function zip_<A, B>(fa: Identity<A>, fb: Identity<B>): Identity<readonly [A, B]>;
+/**
+ * @tsplus getter fncts.Identity getIdentity
+ * @tsplus macro identity
+ * @tsplus location "@fncts/base/data/Identity/api"
+ */
+export declare function getIdentity<A>(self: Identity<A>): A;

package/data/Identity/definition.d.ts

@@ -1,10 +1,15 @@
+import { Newtype, NewtypeIso } from "@fncts/base/data/Newtype";
+export interface IdentityN {
+    readonly [HKT.T]: Identity<HKT._A<this>>;
+}
 /**
  * @tsplus type fncts.Identity
  */
-export declare type Identity<A> = A;
+export interface Identity<A> extends Newtype<"Identity", A> {
+}
 /**
  * @tsplus type fncts.IdentityOps
  */
-export interface IdentityOps {
+export interface IdentityOps extends NewtypeIso<IdentityN> {
 }
 export declare const Identity: IdentityOps;