@fncts/base 0.0.21 → 0.0.23

package/control/Eval/definition.d.ts

@@ -1,4 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
+export declare const EvalVariance: unique symbol;
+export type EvalVariance = typeof EvalVariance;
 export declare const EvalTypeId: unique symbol;
 export type EvalTypeId = typeof EvalTypeId;
 export interface EvalF extends HKT {
@@ -11,8 +13,10 @@ export interface EvalF extends HKT {
  * @tsplus type fncts.control.Eval
  */
 export interface Eval<A> {
-    readonly _typeId: EvalTypeId;
-    readonly _A: () => A;
+    readonly [EvalTypeId]: EvalTypeId;
+    readonly [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus type fncts.control.EvalOps
@@ -28,13 +32,18 @@ export declare const enum EvalTag {
 export declare class Value<A> implements Eval<A> {
     readonly value: A;
     readonly _tag = EvalTag.Value;
-    readonly _typeId: EvalTypeId;
-    readonly _A: () => A;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
     constructor(value: A);
 }
 export declare class Defer<A> implements Eval<A> {
     readonly make: () => Eval<A>;
-    readonly _typeId: EvalTypeId;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => A;
+    };
     readonly _tag = EvalTag.Defer;
     readonly _A: () => A;
     constructor(make: () => Eval<A>);
@@ -42,9 +51,11 @@ export declare class Defer<A> implements Eval<A> {
 export declare class Chain<A, B> implements Eval<B> {
     readonly self: Eval<A>;
     readonly f: (a: A) => Eval<B>;
-    readonly _typeId: EvalTypeId;
+    readonly [EvalTypeId]: EvalTypeId;
+    [EvalVariance]: {
+        readonly _A: (_: never) => B;
+    };
     readonly _tag = EvalTag.Chain;
-    readonly _A: () => B;
     constructor(self: Eval<A>, f: (a: A) => Eval<B>);
 }
 type Concrete = Value<any> | Defer<any> | Chain<any, any>;

package/control/Z/api.d.ts

@@ -18,15 +18,15 @@ export declare function absolve<W, S1, S2, R, E, E1, A>(fa: Z<W, S1, S2, R, E, E
  */
 export declare function ap<W, S, A, R1, E1>(fb: Z<W, S, S, R1, E1, A>): <R, E, B>(self: import("./definition.js").Z<W, S, S, R, E, (a: A) => B>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
 /**
- * @tsplus pipeable fncts.control.Z apFirst
+ * @tsplus pipeable fncts.control.Z zipLeft
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function apFirst<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, A>;
+export declare function zipLeft<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, A>;
 /**
- * @tsplus pipeable fncts.control.Z apSecond
+ * @tsplus pipeable fncts.control.Z zipRight
  * @tsplus location "@fncts/base/control/Z/api"
  */
-export declare function apSecond<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
+export declare function zipRight<W, S, R1, E1, B>(fb: Z<W, S, S, R1, E1, B>): <R, E, A>(fa: import("./definition.js").Z<W, S, S, R, E, A>) => import("./definition.js").Z<W, S, S, R & R1, E1 | E, B>;
 /**
  * @tsplus pipeable fncts.control.Z bimap
  * @tsplus location "@fncts/base/control/Z/api"

package/control/Z/definition.d.ts

@@ -12,6 +12,8 @@ export interface ZF extends HKT {
         A: "+";
     };
 }
+export declare const ZVariance: unique symbol;
+export type ZVariance = typeof ZVariance;
 export declare const ZTypeId: unique symbol;
 export type ZTypeId = typeof ZTypeId;
 /**
@@ -28,13 +30,15 @@ export type ZTypeId = typeof ZTypeId;
  * @tsplus companion fncts.control.ZOps
  */
 export declare abstract class Z<W, S1, S2, R, E, A> {
-    readonly _typeId: ZTypeId;
-    readonly _W: () => W;
-    readonly _S1: (_: S1) => void;
-    readonly _S2: () => S2;
-    readonly _R: () => R;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [ZTypeId]: ZTypeId;
+    [ZVariance]: {
+        readonly _W: (_: never) => W;
+        readonly _S1: (_: S1) => void;
+        readonly _S2: (_: never) => S2;
+        readonly _R: (_: never) => R;
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus unify fncts.control.Z
@@ -141,7 +145,7 @@ export declare const ZErrorTypeId: unique symbol;
 export type ZErrorTypeId = typeof ZErrorTypeId;
 export declare class ZError<E> {
     readonly cause: Cause<E>;
-    readonly _typeId: ZErrorTypeId;
+    readonly [ZErrorTypeId]: ZErrorTypeId;
     constructor(cause: Cause<E>);
 }
 export declare function isZError(u: unknown): u is ZError<unknown>;

package/data/Branded.d.ts

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

package/data/CaseClass.d.ts

@@ -1,6 +1,6 @@
 import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 import type { Equals } from "@fncts/typelevel/Any";
 import type { True } from "@fncts/typelevel/Boolean";
 export declare const CaseClassTypeId: unique symbol;

package/data/Cause/api.d.ts

@@ -194,6 +194,18 @@ export declare function isInterrupt<E>(self: Cause<E>): self is Interrupt;
  * @tsplus location "@fncts/base/data/Cause/api"
  */
 export declare function isInterrupted<E>(self: Cause<E>): boolean;
+/**
+ * Determines if the `Cause` contains only interruptions and not any `Die` or
+ * `Fail` causes.
+ * @tsplus getter fncts.Cause isInterruptedOnly
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isInterruptedOnly<E>(self: Cause<E>): boolean;
+/**
+ * @tsplus getter fncts.Cause isFailure
+ * @tsplus location "@fncts/base/data/Cause/api"
+ */
+export declare function isFailure<E>(self: Cause<E>): boolean;
 /**
  * A type-guard matching `Traced`
  * @tsplus getter fncts.Cause isTraced

package/data/Cause/definition.d.ts

@@ -4,6 +4,8 @@ import { FiberId } from "@fncts/base/data/FiberId/definition";
 import { Conc } from "@fncts/base/collection/immutable/Conc";
 import { List } from "@fncts/base/collection/immutable/List/definition";
 import { HashSet } from "@fncts/base/collection/immutable/HashSet/definition";
+export declare const CauseVariance: unique symbol;
+export type CauseVariance = typeof CauseVariance;
 export declare const CauseTypeId: unique symbol;
 export type CauseTypeId = typeof CauseTypeId;
 /**
@@ -30,8 +32,10 @@ export declare const enum CauseTag {
  * @tsplus companion fncts.Cause.EmptyOps
  */
 export declare class Empty {
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Empty;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -44,8 +48,10 @@ export declare const _Empty: Empty;
 export declare class Fail<E> {
     readonly value: E;
     readonly trace: Trace;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Fail;
     constructor(value: E, trace: Trace);
     get [Symbol.hash](): number;
@@ -58,8 +64,10 @@ export declare class Fail<E> {
 export declare class Halt {
     readonly value: unknown;
     readonly trace: Trace;
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Halt;
     constructor(value: unknown, trace: Trace);
     get [Symbol.hash](): number;
@@ -72,8 +80,10 @@ export declare class Halt {
 export declare class Interrupt {
     readonly id: FiberId;
     readonly trace: Trace;
-    readonly _E: () => never;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => never;
+    };
     readonly _tag = CauseTag.Interrupt;
     constructor(id: FiberId, trace: Trace);
     get [Symbol.hash](): number;
@@ -86,8 +96,10 @@ export declare class Interrupt {
 export declare class Then<E> {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Then;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
@@ -100,8 +112,10 @@ export declare class Then<E> {
 export declare class Both<E> {
     readonly left: Cause<E>;
     readonly right: Cause<E>;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Both;
     constructor(left: Cause<E>, right: Cause<E>);
     get [Symbol.hash](): number;
@@ -114,8 +128,10 @@ export declare class Both<E> {
 export declare class Stackless<E> {
     readonly cause: Cause<E>;
     readonly stackless: boolean;
-    readonly _E: () => E;
     readonly [CauseTypeId]: CauseTypeId;
+    [CauseVariance]: {
+        readonly _E: (_: never) => E;
+    };
     readonly _tag = CauseTag.Stackless;
     constructor(cause: Cause<E>, stackless: boolean);
     get [Symbol.hash](): number;

package/data/Datum/api.d.ts

@@ -1,13 +1,13 @@
 import { Datum } from "@fncts/base/data/Datum/definition";
-import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
+import { Refinement } from "@fncts/base/data/Refinement/definition";
 import { Maybe } from "@fncts/base/data/Maybe/definition";
 import { Lazy } from "@fncts/base/data/function/definition";
 import { Either } from "@fncts/base/data/Either/definition";
 import { HKT } from "@fncts/typelevel/HKT";
 import type { DatumF } from "@fncts/base/data/Datum/definition";
+import type { Eq } from "@fncts/base/data/Eq";
 import type * as P from "@fncts/base/typeclass";
-import type { Eq } from "@fncts/base/typeclass/Eq";
 import { Initial, Pending, Refresh, Replete } from "@fncts/base/data/Datum/definition";
 import { Zipped } from "@fncts/base/data/Zipped";
 /**
@@ -80,11 +80,10 @@ export declare function isLoading<A>(self: Datum<A>): self is Pending | Refresh<
  */
 export declare function elem<A>(a: A, /** @tsplus auto */ E: Eq<A>): (self: Datum<A>) => boolean;
 /**
- * @tsplus pipeable fncts.Datum exists
+ * @tsplus pipeable fncts.Datum some
  * @tsplus location "@fncts/base/data/Datum/api"
  */
-export declare function exists<A, B extends A>(p: Refinement<A, B>): (self: Datum<A>) => self is Datum<B>;
-export declare function exists<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
+export declare function some<A>(p: Predicate<A>): (self: Datum<A>) => boolean;
 /**
  * @tsplus pipeable fncts.Datum extend
  * @tsplus location "@fncts/base/data/Datum/api"

package/data/Datum/definition.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
-import { Equatable } from "@fncts/base/typeclass/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
 export declare const enum DatumTag {
     Initial = "Initial",
     Pending = "Pending",
@@ -31,6 +31,7 @@ export declare const Datum: DatumOps;
  */
 export declare class Initial implements Hashable, Equatable {
     readonly _tag = DatumTag.Initial;
+    readonly [DatumTypeId]: DatumTypeId;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
 }
@@ -39,7 +40,7 @@ export declare class Initial implements Hashable, Equatable {
  * @tsplus companion fncts.Datum.PendingOps
  */
 export declare class Pending implements Hashable, Equatable {
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Pending;
     get [Symbol.hash](): number;
     [Symbol.equals](that: unknown): boolean;
@@ -50,7 +51,7 @@ export declare class Pending implements Hashable, Equatable {
  */
 export declare class Refresh<A> implements Hashable, Equatable {
     readonly value: A;
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Refresh;
     constructor(value: A);
     get [Symbol.hash](): number;
@@ -62,7 +63,7 @@ export declare class Refresh<A> implements Hashable, Equatable {
  */
 export declare class Replete<A> implements Hashable, Equatable {
     readonly value: A;
-    readonly _typeId: DatumTypeId;
+    readonly [DatumTypeId]: DatumTypeId;
     readonly _tag = DatumTag.Replete;
     constructor(value: A);
     get [Symbol.hash](): number;

package/data/DatumEither/definition.d.ts

@@ -10,7 +10,6 @@ export interface DatumEitherF extends HKT {
 }
 /**
  * @tsplus type fncts.DatumEither
- * @tsplus no-inherit fncts.Datum
  */
 export type DatumEither<E, A> = Datum<Either<E, A>>;
 /**

package/data/DatumEither.d.ts

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

package/data/DecodeError/definition.d.ts

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

package/data/Decoder/api.d.ts

@@ -1,6 +1,11 @@
 import { These } from "@fncts/base/data/These";
-import { Guard } from "@fncts/base/typeclass/Guard";
+import { Guard } from "@fncts/base/data/Guard";
+import { ImmutableArray } from "@fncts/base/collection/immutable/ImmutableArray/definition";
+import { ImmutableNonEmptyArray } from "@fncts/base/collection/immutable/ImmutableNonEmptyArray/definition";
+import { Conc } from "@fncts/base/collection/immutable/Conc";
+import type { Brand, Validation } from "@fncts/base/data/Branded";
 import type { DecodeError } from "@fncts/base/data/DecodeError";
+import type { Literal } from "@fncts/typelevel/Any";
 import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
@@ -26,28 +31,76 @@ export declare const number: Decoder<number>;
  */
 export declare const boolean: Decoder<boolean>;
 /**
- * @tsplus static fncts.DecoderOps record
  * @tsplus implicit
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare const record: Decoder<{}>;
+export declare const bigint: Decoder<bigint>;
+/**
+ * @tsplus static fncts.DecoderOps object
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const object: Decoder<{}>;
+/**
+ * @tsplus static fncts.DecoderOps unknown
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const unknown: Decoder<unknown>;
+/**
+ * @tsplus static fncts.DecoderOps null
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const _null: Decoder<null>;
+/**
+ * @tsplus static fncts.DecoderOps undefined
+ * @tsplus implicit
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare const _undefined: Decoder<undefined>;
+/**
+ * @tsplus static fncts.DecoderOps nullable
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function nullable<A>(/** @tsplus implicit local */ base: Decoder<A>): Decoder<A | null | undefined>;
 /**
  * @tsplus derive fncts.Decoder lazy
+ * @tsplus static fncts.DecoderOps lazy
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
 export declare function deriveLazy<A>(f: (_: Decoder<A>) => Decoder<A>): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps literal
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function literal<A extends Literal>(value: 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 static fncts.DecoderOps union
  * @tsplus derive fncts.Decoder<|> 30
  * @tsplus location "@fncts/base/data/Decoder/api"
  */
-export declare function deriveUnion<A extends ReadonlyArray<unknown>>(...elements: {
+export declare function union<A extends ReadonlyArray<unknown>>(...elements: {
     [K in keyof A]: Decoder<A[K]>;
 }): Decoder<A[number]>;
+/**
+ * @tsplus static fncts.DecoderOps struct
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function struct<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Decoder<A[K]>;
+}): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps partial
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function partial<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Decoder<A[K]>;
+}): Decoder<Partial<A>>;
 /**
  * @tsplus derive fncts.Decoder<_> 20
  * @tsplus location "@fncts/base/data/Decoder/api"
@@ -64,3 +117,98 @@ export declare function deriveStruct<A extends Record<string, any>>(...[required
         }
     ])
 ] : never): Decoder<A>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveArray<A extends Array<any>>(...[element]: [A] extends [Array<infer _A>] ? Check<Check.IsEqual<A, Array<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps array
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function array<A>(base: Decoder<A>): Decoder<Array<A>>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveReadonlyArray<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps readonlyArray
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function readonlyArray<A>(base: Decoder<A>): Decoder<ReadonlyArray<A>>;
+/**
+ * @tsplus derive fncts.Decoder<_> 15
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveRecord<A extends Record<string, any>>(...[keyGuard, valueDecoder, requiredKeysRecord]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [
+    keyGuard: Guard<X>,
+    valueDecoder: Decoder<Y>,
+    requiredKeysRecord: {
+        [k in X]: 0;
+    }
+] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps record
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function record<A>(codomain: Decoder<A>): Decoder<Record<string, A>>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveImmutableArray<A extends ImmutableArray<any>>(...[array, elem]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps immutableArray
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function immutableArray<A>(base: Decoder<A>): Decoder<ImmutableArray<A>>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<any>>(...[array, elem]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps immutableNonEmptyArray
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function immutableNonEmptyArray<A>(base: Decoder<A>): Decoder<ImmutableNonEmptyArray<A>>;
+/**
+ * @tsplus derive fncts.Decoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveConc<A extends Conc<any>>(...[array, elem]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [array: Decoder<Array<_A>>, elem: Decoder<_A>] : never : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps conc
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function conc<A>(base: Decoder<A>): Decoder<Conc<A>>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
+    base: Decoder<Brand.Unbranded<A>>,
+    brands: {
+        [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
+    }
+] : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps validation
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Decoder<A>) => Decoder<A & { [K in keyof B]: B[K] extends Validation<any, infer S extends string> ? Brand.Valid<A, S> : never; }[number]>;
+/**
+ * @tsplus derive fncts.Decoder<_> 10
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function deriveTuple<A extends ReadonlyArray<unknown>>(...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: {
+    [K in keyof A]: Decoder<A[K]>;
+}] : never): Decoder<A>;
+/**
+ * @tsplus static fncts.DecoderOps tuple
+ * @tsplus location "@fncts/base/data/Decoder/api"
+ */
+export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
+    [K in keyof A]: Decoder<A[K]>;
+}): Decoder<A>;

package/data/Decoder/definition.d.ts

@@ -17,7 +17,7 @@ export interface DecoderF extends HKT {
 export declare class Decoder<in out A> {
     readonly decode: (input: unknown) => These<DecodeError, A>;
     readonly label: string;
-    readonly _typeId: DecoderTypeId;
+    readonly [DecoderTypeId]: DecoderTypeId;
     constructor(decode: (input: unknown) => These<DecodeError, A>, label: string);
 }
 /**

package/data/Duration/api.d.ts

@@ -54,3 +54,8 @@ export declare function difference(that: Duration): (self: Duration) => Duration
  * @tsplus location "@fncts/base/data/Duration/api"
  */
 export declare function fromInterval(start: number, end: number): Duration;
+/**
+ * @tsplus static fncts.DurationOps zero
+ * @tsplus location "@fncts/base/data/Duration/api"
+ */
+export declare const zero: Duration;

package/data/Duration/definition.d.ts

@@ -1,5 +1,5 @@
-import { Equatable } from "@fncts/base/typeclass/Equatable";
-import { Hashable } from "@fncts/base/typeclass/Hashable";
+import { Equatable } from "@fncts/base/data/Equatable";
+import { Hashable } from "@fncts/base/data/Hashable";
 export declare const DurationTypeId: unique symbol;
 export type DurationTypeId = typeof DurationTypeId;
 /**
@@ -8,7 +8,7 @@ export type DurationTypeId = typeof DurationTypeId;
  */
 export declare class Duration implements Equatable, Hashable {
     readonly milliseconds: number;
-    readonly _typeId: DurationTypeId;
+    readonly [DurationTypeId]: DurationTypeId;
     constructor(milliseconds: number);
     [Symbol.equals](that: unknown): boolean;
     get [Symbol.hash](): number;

package/data/Either/definition.d.ts

@@ -3,6 +3,8 @@ export declare const enum EitherTag {
     Left = "Left",
     Right = "Right"
 }
+export declare const EitherVariance: unique symbol;
+export type EitherVariance = typeof EitherVariance;
 export declare const EitherTypeId: unique symbol;
 export type EitherTypeId = typeof EitherTypeId;
 export interface EitherF extends HKT {
@@ -17,9 +19,11 @@ export interface EitherF extends HKT {
  * @tsplus companion fncts.EitherOps
  */
 export declare class Either<E, A> {
-    readonly _typeId: EitherTypeId;
-    readonly _E: () => E;
-    readonly _A: () => A;
+    readonly [EitherTypeId]: EitherTypeId;
+    [EitherVariance]: {
+        readonly _E: (_: never) => E;
+        readonly _A: (_: never) => A;
+    };
 }
 /**
  * @tsplus type fncts.Either.Left

package/data/Either/instances.d.ts

@@ -1,6 +1,6 @@
 import { HKT } from "@fncts/typelevel/HKT";
 import { Predicate } from "@fncts/base/data/Predicate/definition";
-import { Guard } from "@fncts/base/typeclass/Guard";
+import { Guard } from "@fncts/base/data/Guard";
 import { Decoder } from "@fncts/base/data/Decoder/definition";
 import type { EitherF } from "@fncts/base/data/Either/definition.js";
 import { Either } from "@fncts/base/data/Either/definition";

package/data/EitherT/api.d.ts

@@ -32,7 +32,7 @@ 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>): <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>>;
+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: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, B>;
 /**
  * @tsplus static fncts.EitherTOps mapLeft
  * @tsplus location "@fncts/base/data/EitherT/api"
@@ -47,7 +47,7 @@ export declare function bimap<F extends HKT, FC = HKT.None>(F: P.Functor<F, FC>)
  * @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, 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>>;
+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: EitherT<F, FC, K, Q, W, X, I, S, R, FE, E, A>) => EitherT<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]>, E1 | E, B>;
 /**
  * @tsplus static fncts.EitherTOps zipWith
  * @tsplus location "@fncts/base/data/EitherT/api"