@fncts/schema 0.0.1

package/_mjs/Encoder.mjs

@@ -0,0 +1,36 @@
+import * as tsplus_module_1 from "@fncts/base/data/Encoder/api";
+import * as tsplus_module_2 from "@fncts/base/data/function/api";
+import { interpret } from "@fncts/schema/Schema";
+import * as G from "./Guard.mjs";
+export const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: (members, schema) => {
+    const guards = schema.members.map(interpret(G.Schemable));
+    return tsplus_module_1.makeEncoder(inp => {
+      let encoder;
+      for (let i = 0; i < guards.length; i++) {
+        if (guards[i].is(inp)) {
+          encoder = members[i];
+        }
+      }
+      if (!encoder) {
+        throw new Error("BUG: Encoder not found for union");
+      }
+      return encoder.encode(inp);
+    });
+  }
+};
+//# sourceMappingURL=Encoder.mjs.map

package/_mjs/Encoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Encoder.mjs","mappings":";;AAGA,SAASA,SAAS,QAAQ,sBAAsB;AAEhD,OAAO,KAAKC,CAAC,MAAM,aAAY;AAE/B,OAAO,MAAMC,SAAS,GAAgB;EACpCC,OAAO,yBAAiB;EACxBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAiB;EACxBC,QAAQ,0BAAkB;EAC1BC,MAAM,wBAAgB;EACtBC,OAAO,yBAAiB;EACxBC,KAAK,+BAAuB;EAC5BC,MAAM,wBAAgB;EACtBC,KAAK,uBAA6B;EAClCC,IAAI,4BAAc;EAClBC,UAAU,4BAAkC;EAC5CC,KAAK,EAAE,CAACC,OAAO,EAAEC,MAAM,KAAI;IACzB,MAAMC,MAAM,GAAGD,MAAM,CAACD,OAAO,CAACG,GAAG,CAACrB,SAAS,CAACC,CAAC,CAACC,SAAS,CAAC,CAAC;IACzD,OAAOoB,4BAASC,GAAG,IAAI;MACrB,IAAIC,OAAiC;MACrC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGL,MAAM,CAACM,MAAM,EAAED,CAAC,EAAE,EAAE;QACtC,IAAIL,MAAM,CAACK,CAAC,CAAE,CAACE,EAAE,CAACJ,GAAG,CAAC,EAAE;UACtBC,OAAO,GAAGN,OAAO,CAACO,CAAC,CAAE;;;MAGzB,IAAI,CAACD,OAAO,EAAE;QACZ,MAAM,IAAII,KAAK,CAAC,kCAAkC,CAAC;;MAErD,OAAOJ,OAAO,CAACK,MAAM,CAACN,GAAG,CAAC;IAC5B,CAAC,CAAC;EACJ;CACD","names":["interpret","G","Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","schema","guards","map","tsplus_module_1","inp","encoder","i","length","is","Error","encode"],"sourceRoot":"","sources":["../_src/Encoder.ts"],"sourcesContent":[null]}

package/_mjs/Guard.mjs

@@ -0,0 +1,20 @@
+import * as tsplus_module_1 from "@fncts/base/data/Guard/api";
+import * as tsplus_module_2 from "@fncts/base/data/function/api";
+export const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: members => tsplus_module_1.deriveUnion(...members)
+};
+//# sourceMappingURL=Guard.mjs.map

package/_mjs/Guard.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Guard.mjs","mappings":";;AAGA,OAAO,MAAMA,SAAS,GAAc;EAClCC,OAAO,yBAAe;EACtBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAe;EACtBC,QAAQ,0BAAgB;EACxBC,MAAM,wBAAc;EACpBC,OAAO,yBAAe;EACtBC,KAAK,+BAAqB;EAC1BC,MAAM,wBAAc;EACpBC,KAAK,uBAA2B;EAChCC,IAAI,4BAAY;EAChBC,UAAU,4BAAgC;EAC1CC,KAAK,EAAGC,OAAO,IAAKC,4BAAY,GAAGD,OAAO;CAC3C","names":["Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","tsplus_module_1"],"sourceRoot":"","sources":["../_src/Guard.ts"],"sourcesContent":[null]}

package/_mjs/Schema.mjs

@@ -0,0 +1,210 @@
+import * as tsplus_module_1 from "@fncts/base/collection/immutable/Dictionary/definition";
+import * as tsplus_module_2 from "@fncts/base/collection/immutable/Dictionary/api";
+export const SchemaTypeId = /*#__PURE__*/Symbol.for("fncts.schema.Schema");
+export class Schema {
+  constructor() {
+    this._typeId = SchemaTypeId;
+  }
+}
+export class UnknownSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 0 /* SchemaTag.Unknown */;
+  }
+}
+
+export class StringSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 1 /* SchemaTag.String */;
+  }
+}
+
+export class NumberSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 2 /* SchemaTag.Number */;
+  }
+}
+
+export class BooleanSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 3 /* SchemaTag.Boolean */;
+  }
+}
+
+export class BigIntSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 4 /* SchemaTag.BigInt */;
+  }
+}
+
+export class LiteralSchema extends Schema {
+  constructor(value) {
+    super();
+    this.value = value;
+    this._tag = 5 /* SchemaTag.Literal */;
+  }
+}
+
+export class NullableSchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 6 /* SchemaTag.Nullable */;
+  }
+}
+
+export class StructSchema extends Schema {
+  constructor(fields) {
+    super();
+    this.fields = fields;
+    this._tag = 7 /* SchemaTag.Struct */;
+  }
+}
+
+export class PartialSchema extends Schema {
+  constructor(fields) {
+    super();
+    this.fields = fields;
+    this._tag = 8 /* SchemaTag.Partial */;
+  }
+}
+
+export class ArraySchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 9 /* SchemaTag.Array */;
+  }
+}
+
+export class RecordSchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 10 /* SchemaTag.Record */;
+  }
+}
+
+export class TupleSchema extends Schema {
+  constructor(components) {
+    super();
+    this.components = components;
+    this._tag = 11 /* SchemaTag.Tuple */;
+  }
+}
+
+export class LazySchema extends Schema {
+  constructor(make) {
+    super();
+    this.make = make;
+    this._tag = 12 /* SchemaTag.Lazy */;
+  }
+}
+
+export class ValidationSchema extends Schema {
+  constructor(base, validations) {
+    super();
+    this.base = base;
+    this.validations = validations;
+    this._tag = 13 /* SchemaTag.Validation */;
+  }
+}
+
+export class UnionSchema extends Schema {
+  constructor(members) {
+    super();
+    this.members = members;
+    this._tag = 14 /* SchemaTag.Union */;
+  }
+}
+
+export const unknown = /*#__PURE__*/new UnknownSchema();
+export const string = /*#__PURE__*/new StringSchema();
+export const number = /*#__PURE__*/new NumberSchema();
+export const boolean = /*#__PURE__*/new BooleanSchema();
+export const bigint = /*#__PURE__*/new BigIntSchema();
+export function literal(value) {
+  return new LiteralSchema(value);
+}
+export function nullable(base) {
+  return new NullableSchema(base);
+}
+export function struct(fields) {
+  return new StructSchema(fields);
+}
+export function partial(fields) {
+  return new PartialSchema(fields);
+}
+export function array(base) {
+  return new ArraySchema(base);
+}
+export function record(base) {
+  return new RecordSchema(base);
+}
+export function tuple(...components) {
+  return new TupleSchema(components).unsafeCoerce();
+}
+export function lazy(make) {
+  return new LazySchema(make);
+}
+export function validation(...validations) {
+  return base => new ValidationSchema(base, validations).unsafeCoerce();
+}
+export function union(...members) {
+  return new UnionSchema(members);
+}
+export function concrete(_) {
+  //
+}
+function cacheThunk(f) {
+  let cached;
+  return () => {
+    if (!cached) {
+      cached = f();
+    }
+    return cached;
+  };
+}
+export function interpret(S) {
+  return schema => {
+    concrete(schema);
+    switch (schema._tag) {
+      case 0 /* SchemaTag.Unknown */:
+        return S.unknown;
+      case 1 /* SchemaTag.String */:
+        return S.string;
+      case 2 /* SchemaTag.Number */:
+        return S.number;
+      case 3 /* SchemaTag.Boolean */:
+        return S.boolean;
+      case 4 /* SchemaTag.BigInt */:
+        return S.bigint;
+      case 5 /* SchemaTag.Literal */:
+        return S.literal(schema.value);
+      case 12 /* SchemaTag.Lazy */:
+        const cached = cacheThunk(schema.make);
+        return S.lazy(() => interpret(S)(cached()));
+      case 6 /* SchemaTag.Nullable */:
+        return S.nullable(interpret(S)(schema.base));
+      case 7 /* SchemaTag.Struct */:
+        return S.struct(tsplus_module_1.Dictionary.reverseGet(tsplus_module_2.map(interpret(S))(tsplus_module_1.Dictionary.get(schema.fields))));
+      case 8 /* SchemaTag.Partial */:
+        return S.partial(tsplus_module_1.Dictionary.reverseGet(tsplus_module_2.map(interpret(S))(tsplus_module_1.Dictionary.get(schema.fields))));
+      case 9 /* SchemaTag.Array */:
+        return S.array(interpret(S)(schema.base));
+      case 10 /* SchemaTag.Record */:
+        return S.record(interpret(S)(schema.base));
+      case 11 /* SchemaTag.Tuple */:
+        return S.tuple(...schema.components.map(interpret(S)));
+      case 13 /* SchemaTag.Validation */:
+        return S.validation(...schema.validations)(interpret(S)(schema.base));
+      case 14 /* SchemaTag.Union */:
+        return S.union(schema.members.map(interpret(S)), schema);
+    }
+  };
+}
+//# sourceMappingURL=Schema.mjs.map

package/_mjs/Schema.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.mjs","mappings":";;AAIA,OAAO,MAAMA,YAAY,gBAAGC,MAAM,CAACC,GAAG,CAAC,qBAAqB,CAAC;AAyB7D,OAAM,MAAgBC,MAAM;EAA5BC;IACW,YAAO,GAAiBJ,YAAY;EAE/C;;AAEA,OAAM,MAAOK,aAAc,SAAQF,MAAe;EAAlDC;;IACW,SAAI;EACf;;;AAEA,OAAM,MAAOE,YAAa,SAAQH,MAAc;EAAhDC;;IACW,SAAI;EACf;;;AAEA,OAAM,MAAOG,YAAa,SAAQJ,MAAc;EAAhDC;;IACW,SAAI;EACf;;;AAEA,OAAM,MAAOI,aAAc,SAAQL,MAAe;EAAlDC;;IACW,SAAI;EACf;;;AAEA,OAAM,MAAOK,YAAa,SAAQN,MAAc;EAAhDC;;IACW,SAAI;EACf;;;AAEA,OAAM,MAAOM,aAAiC,SAAQP,MAAS;EAE7DC,YAAqBO,KAAQ;IAC3B,KAAK,EAAE;IADY,UAAK,GAALA,KAAK;IADjB,SAAI;EAGb;;;AAGF,OAAM,MAAOC,cAAkB,SAAQT,MAA4B;EAEjEC,YAAqBS,IAAe;IAClC,KAAK,EAAE;IADY,SAAI,GAAJA,IAAI;IADhB,SAAI;EAGb;;;AAGF,OAAM,MAAOC,YAA4C,SAAQX,MAAS;EAExEC,YAAqBW,MAAwC;IAC3D,KAAK,EAAE;IADY,WAAM,GAANA,MAAM;IADlB,SAAI;EAGb;;;AAGF,OAAM,MAAOC,aAA6C,SAAQb,MAAkB;EAElFC,YAAqBW,MAAwC;IAC3D,KAAK,EAAE;IADY,WAAM,GAANA,MAAM;IADlB,SAAI;EAGb;;;AAGF,OAAM,MAAOE,WAAe,SAAQd,MAAwB;EAE1DC,YAAqBS,IAAe;IAClC,KAAK,EAAE;IADY,SAAI,GAAJA,IAAI;IADhB,SAAI;EAGb;;;AAGF,OAAM,MAAOK,YAAgB,SAAQf,MAAyB;EAE5DC,YAAqBS,IAAe;IAClC,KAAK,EAAE;IADY,SAAI,GAAJA,IAAI;IADhB,SAAI;EAGb;;;AAGF,OAAM,MAAOM,WAA0C,SAAQhB,MAAS;EAEtEC,YAAqBgB,UAA4C;IAC/D,KAAK,EAAE;IADY,eAAU,GAAVA,UAAU;IADtB,SAAI;EAGb;;;AAGF,OAAM,MAAOC,UAAc,SAAQlB,MAAS;EAE1CC,YAAqBkB,IAAqB;IACxC,KAAK,EAAE;IADY,SAAI,GAAJA,IAAI;IADhB,SAAI;EAGb;;;AAGF,OAAM,MAAOC,gBAAiE,SAAQpB,MAErF;EAECC,YAAqBS,IAAe,EAAWW,WAA4B;IACzE,KAAK,EAAE;IADY,SAAI,GAAJX,IAAI;IAAsB,gBAAW,GAAXW,WAAW;IADjD,SAAI;EAGb;;;AAGF,OAAM,MAAOC,WAA0C,SAAQtB,MAAiB;EAE9EC,YAAqBsB,OAAyC;IAC5D,KAAK,EAAE;IADY,YAAO,GAAPA,OAAO;IADnB,SAAI;EAGb;;;AAGF,OAAO,MAAMC,OAAO,gBAAoB,IAAItB,aAAa,EAAE;AAE3D,OAAO,MAAMuB,MAAM,gBAAmB,IAAItB,YAAY,EAAE;AAExD,OAAO,MAAMuB,MAAM,gBAAmB,IAAItB,YAAY,EAAE;AAExD,OAAO,MAAMuB,OAAO,gBAAoB,IAAItB,aAAa,EAAE;AAE3D,OAAO,MAAMuB,MAAM,gBAAmB,IAAItB,YAAY,EAAE;AAExD,OAAM,SAAUuB,OAAO,CAAoBrB,KAAQ;EACjD,OAAO,IAAID,aAAa,CAACC,KAAK,CAAC;AACjC;AAEA,OAAM,SAAUsB,QAAQ,CAAIpB,IAAe;EACzC,OAAO,IAAID,cAAc,CAACC,IAAI,CAAC;AACjC;AAEA,OAAM,SAAUqB,MAAM,CAAgCnB,MAAwC;EAC5F,OAAO,IAAID,YAAY,CAACC,MAAM,CAAC;AACjC;AAEA,OAAM,SAAUoB,OAAO,CAAgCpB,MAAwC;EAC7F,OAAO,IAAIC,aAAa,CAACD,MAAM,CAAC;AAClC;AAEA,OAAM,SAAUqB,KAAK,CAAIvB,IAAe;EACtC,OAAO,IAAII,WAAW,CAACJ,IAAI,CAAC;AAC9B;AAEA,OAAM,SAAUwB,MAAM,CAAIxB,IAAe;EACvC,OAAO,IAAIK,YAAY,CAACL,IAAI,CAAC;AAC/B;AAEA,OAAM,SAAUyB,KAAK,CAA+B,GAAGlB,UAA4C;EACjG,OAAO,IAAID,WAAW,CAACC,UAAU,CAAC,CAACmB,YAAY,EAAE;AACnD;AAEA,OAAM,SAAUC,IAAI,CAAIlB,IAAqB;EAC3C,OAAO,IAAID,UAAU,CAACC,IAAI,CAAC;AAC7B;AAEA,OAAM,SAAUmB,UAAU,CAAiD,GAAGjB,WAAc;EAC1F,OACEX,IAAe,IAEf,IAAIU,gBAAgB,CAACV,IAAI,EAAEW,WAAW,CAAC,CAACe,YAAY,EAAE;AAC1D;AAEA,OAAM,SAAUG,KAAK,CAA+B,GAAGhB,OAAyC;EAC9F,OAAO,IAAID,WAAW,CAACC,OAAO,CAAC;AACjC;AAmBA,OAAM,SAAUiB,QAAQ,CAACC,CAAc;EACrC;AAAA;AAGF,SAASC,UAAU,CAAIC,CAAU;EAC/B,IAAIC,MAAS;EACb,OAAO,MAAK;IACV,IAAI,CAACA,MAAM,EAAE;MACXA,MAAM,GAAGD,CAAC,EAAE;;IAEd,OAAOC,MAAM;EACf,CAAC;AACH;AAGA,OAAM,SAAUC,SAAS,CAAgBC,CAAO;EAC9C,OAAWC,MAAiB,IAA2B;IACrDP,QAAQ,CAACO,MAAM,CAAC;IAChB,QAAQA,MAAM,CAACC,IAAI;MACjB;QACE,OAAOF,CAAC,CAACtB,OAAO;MAClB;QACE,OAAOsB,CAAC,CAACrB,MAAM;MACjB;QACE,OAAOqB,CAAC,CAACpB,MAAM;MACjB;QACE,OAAOoB,CAAC,CAACnB,OAAO;MAClB;QACE,OAAOmB,CAAC,CAAClB,MAAM;MACjB;QACE,OAAOkB,CAAC,CAACjB,OAAO,CAACkB,MAAM,CAACvC,KAAK,CAAC;MAChC;QACE,MAAMoC,MAAM,GAAGF,UAAU,CAACK,MAAM,CAAC5B,IAAI,CAAC;QACtC,OAAO2B,CAAC,CAACT,IAAI,CAAC,MAAMQ,SAAS,CAACC,CAAC,CAAC,CAACF,MAAM,EAAE,CAAC,CAAC;MAC7C;QACE,OAAOE,CAAC,CAAChB,QAAQ,CAACe,SAAS,CAACC,CAAC,CAAC,CAACC,MAAM,CAACrC,IAAI,CAAC,CAAC;MAC9C;QACE,OAAOoC,CAAC,CAACf,MAAM,CAACkB,0BAAU,CAACC,UAAU,CAACC,oBAAkCN,SAAS,CAACC,CAAC,CAAC,EAA9CG,0BAAU,CAACG,GAAG,CAACL,MAAM,CAACnC,MAAM,CAAC,CAAkB,CAAC,CAAC;MACzF;QACE,OAAOkC,CAAC,CAACd,OAAO,CAACiB,0BAAU,CAACC,UAAU,CAACC,oBAAkCN,SAAS,CAACC,CAAC,CAAC,EAA9CG,0BAAU,CAACG,GAAG,CAACL,MAAM,CAACnC,MAAM,CAAC,CAAkB,CAAC,CAAC;MAC1F;QACE,OAAOkC,CAAC,CAACb,KAAK,CAACY,SAAS,CAACC,CAAC,CAAC,CAACC,MAAM,CAACrC,IAAI,CAAC,CAAC;MAC3C;QACE,OAAOoC,CAAC,CAACZ,MAAM,CAACW,SAAS,CAACC,CAAC,CAAC,CAACC,MAAM,CAACrC,IAAI,CAAC,CAAC;MAC5C;QACE,OAAOoC,CAAC,CAACX,KAAK,CAAC,GAAGY,MAAM,CAAC9B,UAAU,CAACoC,GAAG,CAACR,SAAS,CAACC,CAAC,CAAC,CAAC,CAAC;MACxD;QACE,OAAOA,CAAC,CAACR,UAAU,CAAC,GAAGS,MAAM,CAAC1B,WAAW,CAAC,CAACwB,SAAS,CAACC,CAAC,CAAC,CAACC,MAAM,CAACrC,IAAI,CAAC,CAAC;MACvE;QACE,OAAOoC,CAAC,CAACP,KAAK,CAACQ,MAAM,CAACxB,OAAO,CAAC8B,GAAG,CAACR,SAAS,CAACC,CAAC,CAAC,CAAC,EAAEC,MAAM,CAAC;IAAC;EAE/D,CAAC;AACH","names":["SchemaTypeId","Symbol","for","Schema","constructor","UnknownSchema","StringSchema","NumberSchema","BooleanSchema","BigIntSchema","LiteralSchema","value","NullableSchema","base","StructSchema","fields","PartialSchema","ArraySchema","RecordSchema","TupleSchema","components","LazySchema","make","ValidationSchema","validations","UnionSchema","members","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","unsafeCoerce","lazy","validation","union","concrete","_","cacheThunk","f","cached","interpret","S","schema","_tag","tsplus_module_1","reverseGet","tsplus_module_2","get","map"],"sourceRoot":"","sources":["../_src/Schema.ts"],"sourcesContent":[null]}

package/_mjs/Schemable.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=Schemable.mjs.map

package/_mjs/Schemable.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schemable.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_mjs/global.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=global.mjs.map

package/_mjs/global.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_mjs/index.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=index.mjs.map

package/_mjs/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_src/Decoder.ts

@@ -0,0 +1,20 @@
+import type { DecoderF } from "@fncts/base/data/Decoder";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+
+export const Schemable: S<DecoderF> = {
+  unknown: Decoder.unknown,
+  string: Derive(),
+  number: Derive(),
+  boolean: Derive(),
+  bigint: Derive(),
+  literal: Decoder.literal,
+  nullable: Decoder.nullable,
+  struct: Decoder.struct,
+  partial: Decoder.partial,
+  array: Decoder.readonlyArray,
+  record: Decoder.record,
+  tuple: unsafeCoerce(Decoder.tuple),
+  lazy: Decoder.lazy,
+  validation: unsafeCoerce(Decoder.validation),
+  union: (members) => Decoder.union(...members),
+};

package/_src/Encoder.ts

@@ -0,0 +1,38 @@
+import type { EncoderF } from "@fncts/base/data/Encoder";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+
+import { interpret } from "@fncts/schema/Schema";
+
+import * as G from "./Guard.js";
+
+export const Schemable: S<EncoderF> = {
+  unknown: Encoder.unknown,
+  string: Derive(),
+  number: Derive(),
+  boolean: Derive(),
+  bigint: Derive(),
+  literal: Encoder.literal,
+  nullable: Encoder.nullable,
+  struct: Encoder.struct,
+  partial: Encoder.partial,
+  array: Encoder.readonlyArray,
+  record: Encoder.record,
+  tuple: unsafeCoerce(Encoder.tuple),
+  lazy: Encoder.lazy,
+  validation: unsafeCoerce(Encoder.validation),
+  union: (members, schema) => {
+    const guards = schema.members.map(interpret(G.Schemable));
+    return Encoder((inp) => {
+      let encoder: Encoder<any> | undefined;
+      for (let i = 0; i < guards.length; i++) {
+        if (guards[i]!.is(inp)) {
+          encoder = members[i]!;
+        }
+      }
+      if (!encoder) {
+        throw new Error("BUG: Encoder not found for union");
+      }
+      return encoder.encode(inp);
+    });
+  },
+};

package/_src/Guard.ts

@@ -0,0 +1,20 @@
+import type { GuardF } from "@fncts/base/data/Guard";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+
+export const Schemable: S<GuardF> = {
+  unknown: Guard.unknown,
+  string: Derive(),
+  number: Derive(),
+  boolean: Derive(),
+  bigint: Derive(),
+  literal: Guard.literal,
+  nullable: Guard.nullable,
+  struct: Guard.struct,
+  partial: Guard.partial,
+  array: Guard.readonlyArray,
+  record: Guard.record,
+  tuple: unsafeCoerce(Guard.tuple),
+  lazy: Guard.lazy,
+  validation: unsafeCoerce(Guard.validation),
+  union: (members) => Guard.union(...members),
+};

package/_src/Schema.ts

@@ -0,0 +1,249 @@
+import type { Brand, Validation } from "@fncts/base/data/Branded";
+import type { Schemable as S, SchemableKind } from "@fncts/schema/Schemable";
+import type { Literal } from "@fncts/typelevel/Any";
+
+export const SchemaTypeId = Symbol.for("fncts.schema.Schema");
+export type SchemaTypeId = typeof SchemaTypeId;
+
+export const enum SchemaTag {
+  Unknown,
+  String,
+  Number,
+  Boolean,
+  BigInt,
+  Literal,
+  Nullable,
+  Struct,
+  Partial,
+  Array,
+  Record,
+  Tuple,
+  Lazy,
+  Validation,
+  Union,
+}
+
+export interface SchemaF extends HKT {
+  readonly type: Schema<this["A"]>;
+}
+
+export abstract class Schema<in out A> {
+  readonly _typeId: SchemaTypeId = SchemaTypeId;
+  declare _A: (_: A) => A;
+}
+
+export class UnknownSchema extends Schema<unknown> {
+  readonly _tag = SchemaTag.Unknown;
+}
+
+export class StringSchema extends Schema<string> {
+  readonly _tag = SchemaTag.String;
+}
+
+export class NumberSchema extends Schema<number> {
+  readonly _tag = SchemaTag.Number;
+}
+
+export class BooleanSchema extends Schema<boolean> {
+  readonly _tag = SchemaTag.Boolean;
+}
+
+export class BigIntSchema extends Schema<bigint> {
+  readonly _tag = SchemaTag.BigInt;
+}
+
+export class LiteralSchema<A extends Literal> extends Schema<A> {
+  readonly _tag = SchemaTag.Literal;
+  constructor(readonly value: A) {
+    super();
+  }
+}
+
+export class NullableSchema<A> extends Schema<A | null | undefined> {
+  readonly _tag = SchemaTag.Nullable;
+  constructor(readonly base: Schema<A>) {
+    super();
+  }
+}
+
+export class StructSchema<A extends Record<string, any>> extends Schema<A> {
+  readonly _tag = SchemaTag.Struct;
+  constructor(readonly fields: { [K in keyof A]: Schema<A[K]> }) {
+    super();
+  }
+}
+
+export class PartialSchema<A extends Record<string, any>> extends Schema<Partial<A>> {
+  readonly _tag = SchemaTag.Partial;
+  constructor(readonly fields: { [K in keyof A]: Schema<A[K]> }) {
+    super();
+  }
+}
+
+export class ArraySchema<A> extends Schema<ReadonlyArray<A>> {
+  readonly _tag = SchemaTag.Array;
+  constructor(readonly base: Schema<A>) {
+    super();
+  }
+}
+
+export class RecordSchema<A> extends Schema<Record<string, A>> {
+  readonly _tag = SchemaTag.Record;
+  constructor(readonly base: Schema<A>) {
+    super();
+  }
+}
+
+export class TupleSchema<A extends ReadonlyArray<any>> extends Schema<A> {
+  readonly _tag = SchemaTag.Tuple;
+  constructor(readonly components: { [K in keyof A]: Schema<A[K]> }) {
+    super();
+  }
+}
+
+export class LazySchema<A> extends Schema<A> {
+  readonly _tag = SchemaTag.Lazy;
+  constructor(readonly make: () => Schema<A>) {
+    super();
+  }
+}
+
+export class ValidationSchema<A, B extends ReadonlyArray<Validation<A, any>>> extends Schema<
+  A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never }[number]
+> {
+  readonly _tag = SchemaTag.Validation;
+  constructor(readonly base: Schema<A>, readonly validations: readonly [...B]) {
+    super();
+  }
+}
+
+export class UnionSchema<A extends ReadonlyArray<any>> extends Schema<A[number]> {
+  readonly _tag = SchemaTag.Union;
+  constructor(readonly members: { [K in keyof A]: Schema<A[K]> }) {
+    super();
+  }
+}
+
+export const unknown: Schema<unknown> = new UnknownSchema();
+
+export const string: Schema<string> = new StringSchema();
+
+export const number: Schema<number> = new NumberSchema();
+
+export const boolean: Schema<boolean> = new BooleanSchema();
+
+export const bigint: Schema<bigint> = new BigIntSchema();
+
+export function literal<A extends Literal>(value: A): Schema<A> {
+  return new LiteralSchema(value);
+}
+
+export function nullable<A>(base: Schema<A>): Schema<A | null | undefined> {
+  return new NullableSchema(base);
+}
+
+export function struct<A extends Record<string, any>>(fields: { [K in keyof A]: Schema<A[K]> }): Schema<A> {
+  return new StructSchema(fields);
+}
+
+export function partial<A extends Record<string, any>>(fields: { [K in keyof A]: Schema<A[K]> }): Schema<Partial<A>> {
+  return new PartialSchema(fields);
+}
+
+export function array<A>(base: Schema<A>): Schema<ReadonlyArray<A>> {
+  return new ArraySchema(base);
+}
+
+export function record<A>(base: Schema<A>): Schema<Record<string, A>> {
+  return new RecordSchema(base);
+}
+
+export function tuple<A extends ReadonlyArray<any>>(...components: { [K in keyof A]: Schema<A[K]> }): Schema<A> {
+  return new TupleSchema(components).unsafeCoerce();
+}
+
+export function lazy<A>(make: () => Schema<A>): Schema<A> {
+  return new LazySchema(make);
+}
+
+export function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B) {
+  return (
+    base: Schema<A>,
+  ): Schema<A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never }[number]> =>
+    new ValidationSchema(base, validations).unsafeCoerce();
+}
+
+export function union<A extends ReadonlyArray<any>>(...members: { [K in keyof A]: Schema<A[K]> }): Schema<A[number]> {
+  return new UnionSchema(members);
+}
+
+export type Concrete =
+  | UnknownSchema
+  | StringSchema
+  | NumberSchema
+  | BooleanSchema
+  | BigIntSchema
+  | LiteralSchema<any>
+  | NullableSchema<any>
+  | StructSchema<Record<string, any>>
+  | PartialSchema<Record<string, any>>
+  | ArraySchema<any>
+  | RecordSchema<any>
+  | TupleSchema<ReadonlyArray<any>>
+  | LazySchema<any>
+  | ValidationSchema<any, ReadonlyArray<Validation<any, any>>>
+  | UnionSchema<ReadonlyArray<any>>;
+
+export function concrete(_: Schema<any>): asserts _ is Concrete {
+  //
+}
+
+function cacheThunk<A>(f: () => A): () => A {
+  let cached: A;
+  return () => {
+    if (!cached) {
+      cached = f();
+    }
+    return cached;
+  };
+}
+
+export function interpret<F extends HKT>(S: S<F>): <A>(schema: Schema<A>) => SchemableKind<F, A>;
+export function interpret<F extends HKT>(S: S<F>) {
+  return <A>(schema: Schema<A>): SchemableKind<F, any> => {
+    concrete(schema);
+    switch (schema._tag) {
+      case SchemaTag.Unknown:
+        return S.unknown;
+      case SchemaTag.String:
+        return S.string;
+      case SchemaTag.Number:
+        return S.number;
+      case SchemaTag.Boolean:
+        return S.boolean;
+      case SchemaTag.BigInt:
+        return S.bigint;
+      case SchemaTag.Literal:
+        return S.literal(schema.value);
+      case SchemaTag.Lazy:
+        const cached = cacheThunk(schema.make);
+        return S.lazy(() => interpret(S)(cached()));
+      case SchemaTag.Nullable:
+        return S.nullable(interpret(S)(schema.base));
+      case SchemaTag.Struct:
+        return S.struct(Dictionary.reverseGet(Dictionary.get(schema.fields).map(interpret(S))));
+      case SchemaTag.Partial:
+        return S.partial(Dictionary.reverseGet(Dictionary.get(schema.fields).map(interpret(S))));
+      case SchemaTag.Array:
+        return S.array(interpret(S)(schema.base));
+      case SchemaTag.Record:
+        return S.record(interpret(S)(schema.base));
+      case SchemaTag.Tuple:
+        return S.tuple(...schema.components.map(interpret(S)));
+      case SchemaTag.Validation:
+        return S.validation(...schema.validations)(interpret(S)(schema.base));
+      case SchemaTag.Union:
+        return S.union(schema.members.map(interpret(S)), schema);
+    }
+  };
+}

package/_src/Schemable.ts

@@ -0,0 +1,46 @@
+import type { Brand, Validation } from "@fncts/base/data/Branded";
+import type { UnionSchema } from "@fncts/schema/Schema";
+import type { Literal } from "@fncts/typelevel/Any";
+
+export type SchemableKind<F extends HKT, A> = F extends { readonly type: unknown }
+  ? (F & { readonly A: A })["type"]
+  : {
+      readonly _F: F;
+      readonly _A: A;
+    };
+
+export interface Schemable<F extends HKT> {
+  readonly unknown: SchemableKind<F, unknown>;
+  readonly string: SchemableKind<F, string>;
+  readonly number: SchemableKind<F, number>;
+  readonly boolean: SchemableKind<F, boolean>;
+  readonly bigint: SchemableKind<F, bigint>;
+  readonly literal: <A extends Literal>(literal: A) => SchemableKind<F, A>;
+  readonly nullable: <A>(or: SchemableKind<F, A>) => SchemableKind<F, A | null | undefined>;
+  readonly struct: <P extends Record<string, any>>(properties: {
+    [K in keyof P]: SchemableKind<F, P[K]>;
+  }) => SchemableKind<F, P>;
+  readonly partial: <P extends Record<string, any>>(properties: {
+    [K in keyof P]: SchemableKind<F, P[K]>;
+  }) => SchemableKind<F, Partial<P>>;
+  readonly array: <A>(item: SchemableKind<F, A>) => SchemableKind<F, ReadonlyArray<A>>;
+  readonly record: <A>(codomain: SchemableKind<F, A>) => SchemableKind<F, Record<string, A>>;
+  readonly tuple: <C extends ReadonlyArray<any>>(
+    ...components: {
+      [K in keyof C]: SchemableKind<F, C[K]>;
+    }
+  ) => SchemableKind<F, C>;
+  readonly lazy: <A>(f: () => SchemableKind<F, A>) => SchemableKind<F, A>;
+  readonly validation: <A, B extends ReadonlyArray<Validation<A, any>>>(
+    ...validations: B
+  ) => (
+    base: SchemableKind<F, A>,
+  ) => SchemableKind<
+    F,
+    A & { [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never }[number]
+  >;
+  readonly union: <A extends ReadonlyArray<any>>(
+    members: { [K in keyof A]: SchemableKind<F, A[K]> },
+    schema: UnionSchema<A>,
+  ) => SchemableKind<F, A[number]>;
+}