@fncts/base 0.0.21 → 0.0.22

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",

package/data/DecodeError/definition.d.ts

@@ -1,6 +1,7 @@
 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 {
@@ -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/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;
 /**

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/Encoder/api.d.ts

@@ -1,6 +1,10 @@
-import { Guard } from "@fncts/base/typeclass/Guard";
-import type { Brand } from "../Branded.js";
+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 "../Branded.js";
 import type { Check } from "@fncts/typelevel";
+import type { Literal } from "@fncts/typelevel/Any";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
 import { Encoder } from "./definition.js";
 /**
@@ -8,41 +12,70 @@ import { Encoder } from "./definition.js";
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function makeEncoder<A>(encode: (inp: A) => unknown): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps unknown
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const unknown: Encoder<unknown>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps boolean
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const boolean: Encoder<boolean>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps number
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const number: Encoder<number>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps string
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare const string: Encoder<string>;
+/**
+ * @tsplus implicit
+ * @tsplus static fncts.EncoderOps bigint
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare const string: Encoder<number>;
+export declare const bigint: Encoder<bigint>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps null
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare const _null: Encoder<null>;
 /**
  * @tsplus implicit
+ * @tsplus static fncts.EncoderOps undefined
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare const date: Encoder<Date>;
+export declare const _undefined: Encoder<undefined>;
 /**
- * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus implicit
+ * @tsplus static fncts.EncoderOps date
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
-export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never): Encoder<A>;
+export declare const date: Encoder<Date>;
 /**
  * @tsplus derive fncts.Encoder lazy
+ * @tsplus static fncts.EncoderOps lazy
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function deriveLazy<A>(fn: (_: Encoder<A>) => Encoder<A>): Encoder<A>;
+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): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps literal
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function literal<A extends Literal>(value: A): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps nullable
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function nullable<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<A | null | undefined>;
 /**
  * @tsplus derive fncts.Encoder<_> 20
  * @tsplus location "@fncts/base/data/Encoder/api"
@@ -59,6 +92,20 @@ export declare function deriveStruct<A extends Record<string, any>>(...[required
         }
     ])
 ] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps struct
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function struct<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps partial
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function partial<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<Partial<A>>;
 /**
  * @tsplus derive fncts.Encoder<|> 30
  * @tsplus location "@fncts/base/data/Encoder/api"
@@ -71,3 +118,97 @@ export declare function deriveUnion<A extends Array<unknown>>(...elements: {
  * @tsplus location "@fncts/base/data/Encoder/api"
  */
 export declare function deriveEmptyRecord<A extends {}>(..._: Check<Check.IsEqual<A, {}>> extends Check.True ? [] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.Array]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/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: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps array
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function array<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<Array<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/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: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps readonlyArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function readonlyArray<A>(/** @tsplus implicit local */ base: Encoder<A>): Encoder<ReadonlyArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveDictionary<A extends Record<string, any>>(...[value]: Check<Check.IsDictionary<A>> extends Check.True ? [value: Encoder<A[keyof A]>] : never): Encoder<A>;
+/**
+ * @tsplus derive fncts.Encoder<_> 15
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveRecord<A extends Record<string, any>>(...[value, requiredKeys]: Check<Check.IsRecord<A>> extends Check.True ? [
+    value: Encoder<A[keyof A]>,
+    requiredKeys: {
+        [K in keyof A]: 0;
+    }
+] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps record
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function record<A>(codomain: Encoder<A>): Encoder<Record<string, A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveImmutableArray<A extends ImmutableArray<any>>(...[element]: [A] extends [ImmutableArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps immutableArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function immutableArray<A>(base: Encoder<A>): Encoder<ImmutableArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.ImmutableNonEmptyArray]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveImmutableNonEmptyArray<A extends ImmutableNonEmptyArray<any>>(...[element]: [A] extends [ImmutableNonEmptyArray<infer _A>] ? Check<Check.IsEqual<A, ImmutableNonEmptyArray<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps immutableNonEmptyArray
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function immutableNonEmptyArray<A>(base: Encoder<A>): Encoder<ImmutableNonEmptyArray<A>>;
+/**
+ * @tsplus derive fncts.Encoder[fncts.Conc]<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveConc<A extends Conc<any>>(...[element]: [A] extends [Conc<infer _A>] ? Check<Check.IsEqual<A, Conc<_A>>> extends Check.True ? [element: Encoder<_A>] : never : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps conc
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function conc<A>(base: Encoder<A>): Encoder<Conc<A>>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base]: Check<Brand.IsValidated<A>> extends Check.True ? [base: Encoder<Brand.Unbranded<A>>] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps validation
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(..._validations: B): (base: Encoder<A>) => Encoder<A & { [K in keyof B]: B[K] extends Validation<any, infer S extends string> ? Brand.Valid<A, S> : never; }[number]>;
+/**
+ * @tsplus derive fncts.Encoder<_> 10
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function deriveTuple<A extends ReadonlyArray<unknown>>(...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: {
+    [K in keyof A]: Encoder<A[K]>;
+}] : never): Encoder<A>;
+/**
+ * @tsplus static fncts.EncoderOps tuple
+ * @tsplus location "@fncts/base/data/Encoder/api"
+ */
+export declare function tuple<A extends ReadonlyArray<unknown>>(...components: {
+    [K in keyof A]: Encoder<A[K]>;
+}): Encoder<A>;

package/data/Encoder/definition.d.ts

@@ -1,3 +1,4 @@
+import { HKT } from "@fncts/typelevel/HKT";
 export declare const EncoderTypeId: unique symbol;
 export type EncoderTypeId = typeof EncoderTypeId;
 /**
@@ -10,3 +11,6 @@ export declare class Encoder<in out A> {
     readonly _typeId: EncoderTypeId;
     constructor(encode: (inp: A) => unknown);
 }
+export interface EncoderF extends HKT {
+    readonly type: Encoder<this["A"]>;
+}

package/data/Environment/definition.d.ts

@@ -1,5 +1,5 @@
-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 { HashMap } from "@fncts/base/collection/immutable/HashMap/definition";
 import { Tag } from "@fncts/base/data/Tag/definition";
 import type { EnvironmentPatch } from "@fncts/base/data/EnvironmentPatch";

package/{typeclass → data}/Eq/definition.d.ts

@@ -2,7 +2,7 @@
  * @tsplus type fncts.Eq
  */
 export interface Eq<A> {
-    readonly equals: (x: A, y: A) => boolean;
+    readonly equals: (y: A) => (x: A) => boolean;
 }
 /**
  * @tsplus type fncts.EqOps
@@ -12,6 +12,6 @@ export interface EqOps {
 export declare const Eq: EqOps;
 /**
  * @tsplus static fncts.EqOps __call
- * @tsplus location "@fncts/base/typeclass/Eq/definition"
+ * @tsplus location "@fncts/base/data/Eq/definition"
  */
-export declare function mkEq<A>(E: Eq<A>): Eq<A>;
+export declare function makeEq<A>(E: Eq<A>): Eq<A>;

package/{typeclass → data}/Eq/derivations.d.ts

@@ -1,14 +1,14 @@
 import type { Check } from "@fncts/typelevel/Check";
 import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
-import { Eq } from "@fncts/base/typeclass/Eq/definition";
+import { Eq } from "@fncts/base/data/Eq";
 /**
  * @tsplus derive fncts.Eq lazy
- * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ * @tsplus location "@fncts/base/data/Eq/derivations"
  */
 export declare function deriveLazy<A>(fn: (_: Eq<A>) => Eq<A>): Eq<A>;
 /**
  * @tsplus derive fncts.Eq<_> 20
- * @tsplus location "@fncts/base/typeclass/Eq/derivations"
+ * @tsplus location "@fncts/base/data/Eq/derivations"
  */
 export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields]: Check<Check.IsStruct<A>> extends Check.True ? [
     ...[

package/{typeclass → data}/Equatable/api.d.ts

@@ -1,11 +1,11 @@
 /**
  * @tsplus static fncts.EquatableOps deepEquals
- * @tsplus location "@fncts/base/typeclass/Equatable/api"
+ * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare const deepEquals: (a: any, b: any, meta?: any) => boolean;
 /**
  * @tsplus static fncts.EquatableOps strictEquals
  * @tsplus operator fncts.Equatable ==
- * @tsplus location "@fncts/base/typeclass/Equatable/api"
+ * @tsplus location "@fncts/base/data/Equatable/api"
  */
 export declare function strictEquals<A>(a: A, b: unknown): boolean;

package/{typeclass → data}/Equatable/definition.d.ts

@@ -1,6 +1,6 @@
 /**
  * @tsplus static fncts.builtin.SymbolOps equals
- * @tsplus location "@fncts/base/typeclass/Equatable/definition"
+ * @tsplus location "@fncts/base/data/Equatable/definition"
  */
 export declare const equalsSymbol: unique symbol;
 /**

package/data/Exit/api.d.ts

@@ -6,27 +6,27 @@ import { Cause } from "@fncts/base/data/Cause/definition";
  * @tsplus pipeable fncts.Exit ap
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function ap<E, A>(fa: Exit<E, A>): <G, B>(fab: import("./definition.js").Exit<G, (a: A) => B>) => import("./definition.js").Exit<E | G, B>;
+export declare function ap<E, A>(that: Exit<E, A>): <G, B>(self: import("./definition.js").Exit<G, (a: A) => B>) => import("./definition.js").Exit<E | G, B>;
 /**
- * @tsplus pipeable fncts.Exit apFirst
+ * @tsplus pipeable fncts.Exit zipLeft
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirst<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeft<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus pipeable fncts.Exit apSecond
+ * @tsplus pipeable fncts.Exit zipRight
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecond<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRight<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
- * @tsplus pipeable fncts.Exit apFirstC
+ * @tsplus pipeable fncts.Exit zipLeftConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apFirstC<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
+export declare function zipLeftConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, A>;
 /**
- * @tsplus pipeable fncts.Exit apSecondC
+ * @tsplus pipeable fncts.Exit zipRightConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function apSecondC<G, B>(fb: Exit<G, B>): <E, A>(fa: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
+export declare function zipRightConcurrent<G, B>(that: Exit<G, B>): <E, A>(self: import("./definition.js").Exit<E, A>) => import("./definition.js").Exit<G | E, B>;
 /**
  * @tsplus pipeable fncts.Exit flatMap
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -43,10 +43,10 @@ export declare function bimap<E1, A, E2, B>(f: (e: E1) => E2, g: (a: A) => B): (
  */
 export declare function collectAll<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
- * @tsplus static fncts.ExitOps collectAllC
+ * @tsplus static fncts.ExitOps collectAllConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function collectAllC<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
+export declare function collectAllConcurrent<E, A>(exits: Conc<Exit<E, A>>): Maybe<Exit<E, Conc<A>>>;
 /**
  * @tsplus getter fncts.Exit flatten
  * @tsplus location "@fncts/base/data/Exit/api"
@@ -83,15 +83,15 @@ export declare function zipWith<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) =>
  */
 export declare function zip<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
 /**
- * @tsplus pipeable fncts.Exit zipWithC
+ * @tsplus pipeable fncts.Exit zipWithConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipWithC<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
+export declare function zipWithConcurrent<A, EB, B, C>(fb: Exit<EB, B>, f: (a: A, b: B) => C): <EA>(fa: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, C>;
 /**
- * @tsplus pipeable fncts.Exit zipC
+ * @tsplus pipeable fncts.Exit zipConcurrent
  * @tsplus location "@fncts/base/data/Exit/api"
  */
-export declare function zipC<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
+export declare function zipConcurrent<EB, B>(that: Exit<EB, B>): <EA, A>(self: import("./definition.js").Exit<EA, A>) => import("./definition.js").Exit<EB | EA, readonly [A, B]>;
 /**
  * @tsplus pipeable fncts.Exit zipWithCause
  * @tsplus location "@fncts/base/data/Exit/api"