functionalscript 0.11.11 → 0.12.0

package/json/module.f.d.ts

@@ -17,5 +17,4 @@ export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) =>
  */
 export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
 export declare const parse: (value: string) => Unknown;
-export declare const isObject: (value: Unknown) => value is Object;
 export {};

package/json/module.f.js

@@ -60,4 +60,7 @@ export const serialize = sort => {
  */
 export const stringify = sort => compose(serialize(sort))(concat);
 export const parse = JSON.parse;
-export const isObject = (value) => typeof value === 'object' && value !== null && !(value instanceof Array);
+/*
+export const isObject = (value: Unknown): value is Object =>
+    typeof value === 'object' && value !== null && !(value instanceof Array)
+*/

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.11",
+  "version": "0.12.0",
   "type": "module",
   "files": [
     "**/*.js",

package/types/array/module.f.d.ts

@@ -3,6 +3,7 @@
  *
  * @module
  */
+export declare const isArray: (value: unknown) => value is readonly unknown[];
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -37,4 +38,5 @@ export declare const splitLast: <T>(a: readonly T[]) => readonly [readonly T[],
  * we may minimize memory a number of memory allocations.
  */
 export declare const empty: readonly [];
+export type Includes<I, T extends readonly I[]> = (v: I) => v is T[number];
 export declare const includes: <I, T extends readonly I[]>(a: T) => (v: I) => v is T[number];

package/types/array/module.f.js

@@ -4,6 +4,7 @@
  * @module
  */
 import { map } from "../nullable/module.f.js";
+export const isArray = (value) => value instanceof Array;
 export const isArray2 = (a) => a.length === 2;
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);

package/types/object/module.f.d.ts

@@ -15,7 +15,7 @@ export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
  * https://stackoverflow.com/questions/57571664/typescript-type-for-an-object-with-only-one-key-no-union-type-allowed-as-a-key
  */
 export type OneKey<K extends string, V> = {
-    [P in K]: (Record<P, V> & Partial<Record<Exclude<K, P>, never>>) extends infer O ? {
+    [P in K]: (ReadonlyRecord<P, V> & Partial<ReadonlyRecord<Exclude<K, P>, never>>) extends infer O ? {
         [Q in keyof O]: O[Q];
     } : never;
 }[K];
@@ -25,4 +25,8 @@ export type OneKey<K extends string, V> = {
 export type NotUnion<T, U = T> = T extends unknown ? [
     U
 ] extends [T] ? T : never : never;
-export type SingleProperty<T extends Record<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export type SingleProperty<T extends ReadonlyRecord<string, never>> = keyof T extends NotUnion<keyof T> ? T : never;
+export declare const isObject: (value: unknown) => value is { readonly [k in string]: unknown; };
+export type ReadonlyRecord<S extends string, T> = {
+    readonly [K in S]: T;
+};

package/types/object/module.f.js

@@ -1,3 +1,4 @@
+import { isArray } from "../array/module.f.js";
 import { iterable } from "../list/module.f.js";
 import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
@@ -8,3 +9,4 @@ export const at = name => object => {
 export const sort = e => mapEntries(mapFromEntries(e));
 export const fromEntries = e => objectFromEntries(iterable(e));
 export const fromMap = m => fromEntries(mapEntries(m));
+export const isObject = (value) => typeof value === 'object' && !isArray(value) && value !== null;

package/types/rtti/module.f.d.ts

@@ -1,48 +1,107 @@
-import { type Result as CommonResult } from "../result/module.f.ts";
-/** Validation result: either the typed value or an error message. */
-export type Result<T extends Type> = CommonResult<Ts<T>, string>;
-declare const objectTypeList: readonly ["null", "array", "record"];
-/** String tags for non-object primitive types. */
-export type NonObjectType = 'undefined' | 'boolean' | 'string' | 'number' | 'bigint' | 'function';
-/** String tags for object types: `'null'`, `'array'`, `'record'`. */
-export type ObjectType = typeof objectTypeList[number];
-/** Union of all base type string tags. */
-export type BaseType = NonObjectType | ObjectType;
 /**
- * A struct schema: an object whose keys are field names and values are nested `Type`s.
- * Used to validate plain objects with specific typed fields.
+ * Runtime type information (RTTI) — a type-safe schema system for describing and
+ * converting TypeScript types.
+ *
+ * ## Core concepts
+ *
+ * A `Type` is either a `Const` (used directly as its own schema) or a `Thunk`
+ * (a zero-argument function returning an `Info` descriptor). Thunks are the
+ * primary building block: they enable lazy evaluation and recursive type definitions.
+ *
+ * ```
+ * Type = Const | Thunk
+ * Thunk = () => Info
+ * Info = ['const', Const] | Info0<Tag0> | Info1<Tag1, Type>
+ * ```
+ *
+ * ## Nullary schemas (no type parameter)
+ *
+ * `boolean`, `number`, `string`, `bigint`, `unknown` are pre-built `Thunk` values
+ * that describe primitive types. Each is a `Type0<Tag0>` — a thunk returning a
+ * single-element tag tuple.
+ *
+ * ## Unary schemas (one type parameter)
+ *
+ * `array(t)` and `record(t)` construct `Thunk` values parameterized by an inner
+ * `Type`. They return `Type1` thunks wrapping an `Info1` tuple.
+ *
+ * ## Const schemas
+ *
+ * Any `Primitive`, `Struct` (plain object), or `Tuple` (readonly array) can be
+ * used directly as a schema — it describes exactly the shape of that value.
+ * Inside a recursive `Thunk`-based definition, wrap consts with `() => ['const', c]`
+ * to keep the schema uniform.
+ *
+ * ## Converting to TypeScript types
+ *
+ * See `./ts/module.f.ts` for `Ts<T>` and the `*Ts` transformer types.
  */
-export type StructType = object & {
+import type { Primitive } from '../../djs/module.f.ts';
+import { type Includes } from '../array/module.f.ts';
+export type ConstObject = Struct | Tuple;
+/** A constant schema: a primitive literal, a struct object, or a tuple. */
+export type Const = Primitive | ConstObject;
+/** A struct schema: plain object whose values are nested `Type`s. */
+export type Struct = {
     readonly [K in string]: Type;
 };
-/** A thunk returning a `NonLazyType`, used for recursive type definitions. */
-export type LazyType = () => NonLazyType;
-/** A `Type` that is not wrapped in a thunk. */
-export type NonLazyType = BaseType | StructType;
-/** Any RTTI type: a base tag string, a struct schema object, or a lazy thunk. */
-export type Type = NonLazyType | LazyType;
-type NonObjectTs<T extends NonObjectType> = T extends 'undefined' ? undefined : T extends 'boolean' ? boolean : T extends 'string' ? string : T extends 'number' ? number : T extends 'bigint' ? bigint : T extends 'function' ? Function : never;
-type ArrayTs = readonly unknown[];
-type RecordTs = object & {
-    readonly [K in string]: unknown;
-};
-type ObjectTs<T extends ObjectType> = T extends 'null' ? null : T extends 'array' ? ArrayTs : T extends 'record' ? RecordTs : never;
-type BaseTs<T extends BaseType> = T extends NonObjectType ? NonObjectTs<T> : T extends ObjectType ? ObjectTs<T> : never;
-type NonLazyTs<T extends NonLazyType> = T extends BaseType ? BaseTs<T> : T extends StructType ? object & {
-    readonly [K in keyof T]: Ts<T[K]>;
-} : never;
-/**
- * Converts an RTTI `Type` to its corresponding TypeScript type.
- * @example `Ts<'string'>` → `string`, `Ts<{ x: 'number' }>` → `{ readonly x: number }`
- */
-export type Ts<T extends Type> = NonLazyTs<ToNonLazy<T>>;
-/** A function that validates an unknown value against type `T`. */
-export type Validate<T extends Type> = (value: unknown) => Result<T>;
-type ToNonLazy<T extends Type> = T extends () => infer R ? R : T;
+/** A tuple schema: readonly array whose elements are nested `Type`s. */
+export type Tuple = readonly Type[];
+declare const primitive0List: readonly ["bigint", "boolean", "number", "string"];
+export type Primitive0 = typeof primitive0List[number];
+export declare const tag0List: readonly ["bigint", "boolean", "number", "string", "unknown"];
+/** Tags for nullary (zero-parameter) type schemas. */
+export type Tag0 = typeof tag0List[number];
+/** Info tuple for a nullary tag: `readonly[tag]`. */
+export type Info0<T extends Tag0> = readonly [T];
 /**
- * Creates a validator function for the given RTTI schema.
- * @param rtti - A base type tag, struct schema, or lazy thunk.
- * @returns A function `(value: unknown) => Result<T>`.
+ * The descriptor returned by a `Thunk`. One of:
+ * - `['const', Const]` — a constant/literal schema (used in recursive thunks)
+ * - `Info0<Tag0>` — a nullary primitive tag
+ * - `Info1<Tag1, Type>` — a unary parametric tag with an inner type
  */
-export declare const validate: <T extends Type>(rtti: T) => Validate<T>;
+export type Info = readonly ['const', Const] | Info0<Tag0> | Info1<Tag1, Type>;
+/** A lazy schema: a zero-argument function returning an `Info` descriptor. */
+export type Thunk = () => Info;
+/** Any schema: a `Const` used directly, or a `Thunk` for tag-based/recursive schemas. */
+export type Type = Const | Thunk;
+/** The type of a nullary thunk for `Tag0`. */
+type Type0<T extends Tag0> = () => Info0<T>;
+/** Schema type for `boolean`. */
+export type Boolean = Type0<'boolean'>;
+/** Schema that validates `boolean` values. */
+export declare const boolean: Boolean;
+/** Schema type for `number`. */
+export type Number = Type0<'number'>;
+/** Schema that validates `number` values. */
+export declare const number: Number;
+/** Schema type for `string`. */
+export type String = Type0<'string'>;
+/** Schema that validates `string` values. */
+export declare const string: String;
+/** Schema type for `bigint`. */
+export type Bigint = Type0<'bigint'>;
+/** Schema that validates `bigint` values. */
+export declare const bigint: Bigint;
+/** Schema type for any DJS value (`Primitive | UnknownRecord | UnknownArray`). */
+export type Unknown = Type0<'unknown'>;
+/** Schema that validates any DJS-compatible value. */
+export declare const unknown: Unknown;
+declare const tag1List: readonly ["array", "record"];
+export declare const isTag1: Includes<string, typeof tag1List>;
+/** Tags for unary (one-parameter) type schemas. */
+export type Tag1 = typeof tag1List[number];
+/** Info tuple for a unary tag: `readonly[tag, innerType]`. */
+export type Info1<K extends Tag1, T extends Type> = readonly [K, T];
+/** The type of a unary thunk for `Tag1` with inner type `T`. */
+export type Type1<K extends Tag1, T extends Type> = () => Info1<K, T>;
+type MakeType1<K extends Tag1> = <T extends Type>(t: T) => Type1<K, T>;
+/** Schema type for a readonly array with element type `T`. */
+export type Array<T extends Type> = Type1<'array', T>;
+/** Constructs a schema that validates `readonly Ts<T>[]`. */
+export declare const array: MakeType1<'array'>;
+/** Schema type for a record (index signature) with value type `T`. */
+export type Record<T extends Type> = Type1<'record', T>;
+/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
+export declare const record: MakeType1<'record'>;
 export {};

package/types/rtti/module.f.js

@@ -1,53 +1,21 @@
-/**
- * Runtime type information (RTTI) for validating unknown values against typed schemas.
- *
- * A `Type` is either a `BaseType` string tag (e.g. `'string'`, `'number'`, `'record'`),
- * a `StructType` object mapping field names to nested `Type`s, or a `LazyType` thunk
- * for recursive definitions. Use {@link validate} to produce a type-safe validator.
- *
- * @module
- */
 import { includes } from "../array/module.f.js";
-import { ok, error } from "../result/module.f.js";
-// object
-const objectTypeList = ['null', 'array', 'record'];
-const isObjectType = includes(objectTypeList);
-const nonObjectValidate = (rtti) => value => typeof value === rtti ? ok(value) : error(rtti);
-const isNull = (v) => v === null;
-const isArray = (v) => v instanceof Array;
-const isRecord = (v) => typeof v === 'object' && !isNull(v) && !isArray(v);
-const wrap = (f) => value => f(value) ? ok(value) : error(`unexpected value: ${value}`);
-const objectSwitch = {
-    null: wrap(isNull),
-    array: wrap(isArray),
-    record: wrap(isRecord),
-};
-const objectValidate = (rtti) => objectSwitch[rtti];
-const baseValidate = (rtti) => isObjectType(rtti) ? objectValidate(rtti) : nonObjectValidate(rtti);
-const recordValidate = (rtti) => value => {
-    if (!isRecord(value)) {
-        return error('record is expected');
-    }
-    for (const [k, t] of Object.entries(rtti)) {
-        const r = validate(t)(value[k]);
-        if (r[0] === 'error') {
-            return r;
-        }
-    }
-    return ok(value);
-};
-const nonLazyValidate = (rtti) => {
-    switch (typeof rtti) {
-        case 'string':
-            return baseValidate(rtti);
-        case 'object':
-            return recordValidate(rtti);
-    }
-};
-const nonLazy = (rtti) => (typeof rtti === 'function' ? rtti() : rtti);
-/**
- * Creates a validator function for the given RTTI schema.
- * @param rtti - A base type tag, struct schema, or lazy thunk.
- * @returns A function `(value: unknown) => Result<T>`.
- */
-export const validate = (rtti) => nonLazyValidate(nonLazy(rtti));
+const primitive0List = ['bigint', 'boolean', 'number', 'string'];
+export const tag0List = [...primitive0List, 'unknown'];
+const type0 = (tag) => () => [tag];
+/** Schema that validates `boolean` values. */
+export const boolean = type0('boolean');
+/** Schema that validates `number` values. */
+export const number = type0('number');
+/** Schema that validates `string` values. */
+export const string = type0('string');
+/** Schema that validates `bigint` values. */
+export const bigint = type0('bigint');
+/** Schema that validates any DJS-compatible value. */
+export const unknown = type0('unknown');
+const tag1List = ['array', 'record'];
+export const isTag1 = includes(tag1List);
+const type1 = (key) => t => () => [key, t];
+/** Constructs a schema that validates `readonly Ts<T>[]`. */
+export const array = type1('array');
+/** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
+export const record = type1('record');

package/types/rtti/test.f.d.ts

@@ -2,53 +2,5 @@ declare const _default: {
     typeof: {
         [k: string]: (() => void)[];
     };
-    validate: {
-        undefined: {
-            ok: () => void;
-            error: () => void;
-        };
-        boolean: {
-            ok: () => void;
-            error: () => void;
-        };
-        string: {
-            ok: () => void;
-            error: () => void;
-        };
-        number: {
-            ok: () => void;
-            error: () => void;
-        };
-        bigint: {
-            ok: () => void;
-            error: () => void;
-        };
-        null: {
-            ok: () => void;
-            error: () => void;
-        };
-        array: {
-            ok: () => void;
-            error: () => void;
-        };
-        record: {
-            ok: () => void;
-            error: () => void;
-        };
-        function: {
-            ok: () => void;
-            error: () => void;
-        };
-        lazy: {
-            ok: () => void;
-            error: () => void;
-        };
-        struct: {
-            ok: () => void;
-            missingField: () => void;
-            wrongFieldType: () => void;
-            notObject: () => void;
-        };
-    };
 };
 export default _default;

package/types/rtti/test.f.js

@@ -1,4 +1,3 @@
-import { validate } from "./module.f.js";
 const tests = {
     undefined: [undefined],
     boolean: [true, false],
@@ -20,70 +19,4 @@ export default {
                 throw `typeof ${v} !== ${k}`;
             }
         })])),
-    validate: {
-        undefined: {
-            ok: () => assertOk(validate('undefined')(undefined)),
-            error: () => assertError(validate('undefined')(null)),
-        },
-        boolean: {
-            ok: () => {
-                assertOk(validate('boolean')(true));
-                assertOk(validate('boolean')(false));
-            },
-            error: () => assertError(validate('boolean')(0)),
-        },
-        string: {
-            ok: () => assertOk(validate('string')('hello')),
-            error: () => assertError(validate('string')(42)),
-        },
-        number: {
-            ok: () => assertOk(validate('number')(3)),
-            error: () => assertError(validate('number')('hello')),
-        },
-        bigint: {
-            ok: () => assertOk(validate('bigint')(4n)),
-            error: () => assertError(validate('bigint')(4)),
-        },
-        null: {
-            ok: () => assertOk(validate('null')(null)),
-            error: () => {
-                assertError(validate('null')(undefined));
-                assertError(validate('null')({}));
-            },
-        },
-        array: {
-            ok: () => {
-                assertOk(validate('array')([]));
-                assertOk(validate('array')([1, 2]));
-            },
-            error: () => {
-                assertError(validate('array')({}));
-                assertError(validate('array')(null));
-            },
-        },
-        record: {
-            ok: () => {
-                assertOk(validate('record')({}));
-                assertOk(validate('record')({ x: 1 }));
-            },
-            error: () => {
-                assertError(validate('record')([]));
-                assertError(validate('record')(null));
-            },
-        },
-        function: {
-            ok: () => assertOk(validate('function')(() => { })),
-            error: () => assertError(validate('function')(null)),
-        },
-        lazy: {
-            ok: () => assertOk(validate(() => 'string')('hello')),
-            error: () => assertError(validate(() => 'string')(42)),
-        },
-        struct: {
-            ok: () => assertOk(validate({ name: 'string', age: 'number' })({ name: 'alice', age: 30 })),
-            missingField: () => assertError(validate({ name: 'string' })({})),
-            wrongFieldType: () => assertError(validate({ name: 'string' })({ name: 42 })),
-            notObject: () => assertError(validate({ name: 'string' })(null)),
-        },
-    }
 };

package/types/rtti/ts/module.f.d.ts

@@ -0,0 +1,39 @@
+import type { Primitive, Unknown as DjsUnknown } from '../../../djs/module.f.ts';
+import type { Tag0, Tag1, Const, Struct, Tuple, Info0, Info1, Info, Type } from '../module.f.ts';
+import type { ReadonlyRecord } from '../../object/module.f.ts';
+/** Maps a `Tag0` to its TypeScript type. */
+export type Info0Ts<T extends Tag0> = T extends 'boolean' ? boolean : T extends 'number' ? number : T extends 'string' ? string : T extends 'bigint' ? bigint : T extends 'unknown' ? DjsUnknown : never;
+/** Maps a `Const` schema to its TypeScript type. */
+export type ConstTs<T extends Const> = T extends Primitive ? T : T extends Tuple ? TupleTs<T> : T extends Struct ? StructTs<T> : never;
+/** Maps a `Tag1` and inner type to its TypeScript type. */
+export type Info1Ts<K extends Tag1, T extends Type> = K extends 'array' ? ArrayTs<T> : K extends 'record' ? RecordTs<T> : never;
+/** Maps an `Info` descriptor to its TypeScript type. */
+export type InfoTs<T extends Info> = T extends readonly ['const', infer C extends Const] ? ConstTs<C> : T extends Info0<infer K extends Tag0> ? Info0Ts<K> : T extends Info1<infer K extends Tag1, infer I extends Type> ? Info1Ts<K, I> : never;
+/** Maps an array schema `T` to `readonly Ts<T>[]`. */
+export type ArrayTs<T extends Type> = ReadonlyArray<Ts<T>>;
+/** Maps a record schema `T` to `{ readonly[K in string]: Ts<T> }`. */
+export type RecordTs<T extends Type> = ReadonlyRecord<string, Ts<T>>;
+export type ClosedTupleTs<T extends Tuple> = {
+    readonly [K in keyof T]: Ts<T[K]>;
+};
+/** Maps a tuple schema to a readonly tuple of resolved types. */
+export type TupleTs<T extends Tuple> = ClosedTupleTs<T>;
+/** Maps a struct schema to a readonly object of resolved types. */
+export type StructTs<T extends Struct> = {
+    readonly [K in keyof T]: Ts<T[K]>;
+};
+/**
+ * Converts a schema `Type` to its corresponding TypeScript type.
+ *
+ * - `Thunk` → evaluates the returned `Info` via `InfoTs`
+ * - `Const` → resolves via `ConstTs` (primitives map to themselves; structs/tuples recurse)
+ *
+ * @example
+ * ```ts
+ * type A = Ts<typeof string>           // string
+ * type B = Ts<4>                       // 4
+ * type C = Ts<Array<typeof number>>    // readonly number[]
+ * type D = Ts<{ x: typeof boolean }>  // { readonly x: boolean }
+ * ```
+ */
+export type Ts<T extends Type> = T extends () => (infer I extends Info) ? InfoTs<I> : T extends Const ? ConstTs<T> : never;

package/types/rtti/ts/module.f.js

@@ -0,0 +1 @@
+import { string, unknown } from "../module.f.js";

package/types/rtti/validate/module.f.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Runtime validation of unknown values against RTTI schemas.
+ *
+ * The main entry point is `validate(rtti)`, which takes a schema `Type` and returns
+ * a `Validate<T>` function. When called with an unknown value, it returns a `Result`
+ * that is either `['ok', typedValue]` or `['error', message]`.
+ *
+ * ## Dispatch strategy
+ *
+ * - **`Thunk`** schemas are evaluated lazily: the thunk is called once to obtain an
+ *   `Info` descriptor, then dispatched by tag:
+ *   - `'const'` — delegates to `constValidate`
+ *   - `'unknown'` — always succeeds (any DJS value is valid)
+ *   - `Tag1` (`'array'`, `'record'`) — delegates to `containerValidate`
+ *   - `Tag0` (`'boolean'`, `'number'`, `'string'`, `'bigint'`) — uses `typeof` check
+ * - **`Const`** schemas (primitives, tuples, structs) validate by exact equality or
+ *   recursive field/element checking.
+ *
+ * ## Recursion safety
+ *
+ * For `array` and `record` schemas, the inner item validator is instantiated lazily —
+ * only after confirming the container is non-empty. This prevents infinite recursion
+ * when validating recursive schemas like `const list = () => ['array', list]`.
+ *
+ * @module
+ */
+import type { Unknown } from '../../../djs/module.f.ts';
+import { type Type } from '../module.f.ts';
+import { type Result as CommonResult } from '../../result/module.f.ts';
+import type { Ts } from '../ts/module.f.ts';
+/** Validation result: either the typed value or an error message. */
+export type Result<T extends Type> = CommonResult<Ts<T>, string>;
+/** A function that validates an unknown value against schema `T`. */
+export type Validate<T extends Type> = (value: Unknown) => Result<T>;
+/**
+ * Creates a validator function for the given RTTI schema.
+ *
+ * @param rtti - A schema `Type`: a `Thunk` for tag-based schemas, or a `Const`
+ *   (primitive literal, tuple, or struct) for exact-value schemas.
+ * @returns A `Validate<T>` function that checks an unknown value and returns
+ *   `['ok', value]` or `['error', message]`.
+ *
+ * @example
+ * ```ts
+ * const v = validate(array(number))
+ * v([1, 2, 3])   // ['ok', [1, 2, 3]]
+ * v(['a', 'b'])  // ['error', 'unexpected value']
+ * ```
+ */
+export declare const validate: <T extends Type>(rtti: T) => Validate<T>;

package/types/rtti/validate/module.f.js

@@ -0,0 +1,100 @@
+import { isTag1 } from "../module.f.js";
+import { error, ok } from "../../result/module.f.js";
+import { isArray as commonIsArray } from "../../array/module.f.js";
+import { isObject as commonIsObject } from "../../object/module.f.js";
+import { identity } from "../../function/module.f.js";
+/**
+ * Builds a validator for `array` or `record` schemas.
+ * The inner item validator is instantiated lazily (only when the container is
+ * non-empty) to avoid infinite recursion with recursive schemas.
+ */
+const containerValidate = (isContainer, getItems) => (item) => value => {
+    if (!isContainer(value)) {
+        return error('unexpected value');
+    }
+    const items = getItems(value);
+    if (items.length === 0) {
+        return ok(value);
+    }
+    // Note: we shouldn't instantiate `itemValidate` until we make sure `items` is not empty.
+    //       Otherwise, we can get infinite recursion on empty arrays and objects
+    const itemValidate = validate(item);
+    for (const i of items) {
+        const r = itemValidate(i);
+        if (r[0] === 'error') {
+            return r;
+        }
+    }
+    return ok(value);
+};
+const isArray = value => commonIsArray(value);
+const arrayValidate = containerValidate(isArray, identity);
+const isObject = value => commonIsObject(value);
+const recordValidate = containerValidate(isObject, Object.values);
+const tag1Validate = ([tag, item]) => tag === 'array'
+    ? arrayValidate(item)
+    : recordValidate(item);
+/** Validates a `Tag0` primitive schema using `typeof`. */
+const primitive0Validate = (tag) => value => typeof value === tag ? ok(value) : error('unexpected value');
+/** Validates a `Thunk` schema by evaluating it once and dispatching on the resulting `Info` tag. */
+const thunkValidate = (rtti) => {
+    const info = rtti();
+    const [tag, value] = info;
+    switch (tag) {
+        case 'const':
+            return constValidate(value);
+        case 'unknown':
+            return ok;
+    }
+    return isTag1(tag)
+        ? tag1Validate(info)
+        : primitive0Validate(tag);
+};
+/**
+ * Builds a validator for `Tuple` or `Struct` const schemas.
+ * Iterates over the schema's entries and validates each corresponding
+ * element/property of the value.
+ */
+const constContainerValidate = (isContainer, getItem) => (rtti) => value => {
+    if (!isContainer(value)) {
+        return error('unexpected value');
+    }
+    for (const [k, v] of Object.entries(rtti)) {
+        const item = getItem(value, k);
+        const r = validate(v)(item);
+        if (r[0] === 'error') {
+            return r;
+        }
+    }
+    return ok(value);
+};
+const tupleValidate = constContainerValidate(isArray, (value, k) => value[Number(k)]);
+const structValidate = constContainerValidate(isObject, (value, k) => value[k]);
+const constObjectValidate = (rtti) => commonIsArray(rtti)
+    ? tupleValidate(rtti)
+    : structValidate(rtti);
+/** Validates a primitive `Const` schema using strict equality (`===`). */
+const constPrimitiveValidate = (rtti) => value => rtti === value
+    ? ok(value)
+    : error('unexpected value');
+const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
+    ? constObjectValidate(rtti)
+    : constPrimitiveValidate(rtti);
+/**
+ * Creates a validator function for the given RTTI schema.
+ *
+ * @param rtti - A schema `Type`: a `Thunk` for tag-based schemas, or a `Const`
+ *   (primitive literal, tuple, or struct) for exact-value schemas.
+ * @returns A `Validate<T>` function that checks an unknown value and returns
+ *   `['ok', value]` or `['error', message]`.
+ *
+ * @example
+ * ```ts
+ * const v = validate(array(number))
+ * v([1, 2, 3])   // ['ok', [1, 2, 3]]
+ * v(['a', 'b'])  // ['error', 'unexpected value']
+ * ```
+ */
+export const validate = (rtti) => typeof rtti === 'function'
+    ? thunkValidate(rtti)
+    : constValidate(rtti);

package/types/rtti/validate/test.f.d.ts

@@ -0,0 +1,76 @@
+declare const _default: {
+    boolean: {
+        ok: () => void;
+        error: () => void;
+    };
+    number: {
+        ok: () => void;
+        error: () => void;
+    };
+    string: {
+        ok: () => void;
+        error: () => void;
+    };
+    bigint: {
+        ok: () => void;
+        error: () => void;
+    };
+    unknown: {
+        ok: () => void;
+    };
+    const: {
+        null: {
+            ok: () => void;
+            error: () => void;
+        };
+        undefined: {
+            ok: () => void;
+            error: () => void;
+        };
+        number: {
+            ok: () => void;
+            error: () => void;
+        };
+        string: {
+            ok: () => void;
+            error: () => void;
+        };
+        bigint: {
+            ok: () => void;
+            error: () => void;
+        };
+        boolean: {
+            ok: () => void;
+            error: () => void;
+        };
+        tuple: {
+            ok: () => void;
+            extraItems: () => void;
+            error: () => void;
+        };
+        struct: {
+            ok: () => void;
+            extraKeys: () => void;
+            error: () => void;
+        };
+    };
+    array: {
+        empty: () => void;
+        ok: () => void;
+        error: () => void;
+        nested: () => void;
+    };
+    record: {
+        empty: () => void;
+        ok: () => void;
+        error: () => void;
+    };
+    constThunk: {
+        primitive: () => void;
+    };
+    recursive: {
+        arrayOfArrays: () => void;
+        recordOfRecords: () => void;
+    };
+};
+export default _default;

package/types/rtti/validate/test.f.js

@@ -0,0 +1,143 @@
+import { validate } from "./module.f.js";
+import { boolean, number, string, bigint, unknown, array, record } from "../module.f.js";
+const assertOk = ([k]) => { if (k !== 'ok') {
+    throw 'expected ok';
+} };
+const assertError = ([k]) => { if (k !== 'error') {
+    throw 'expected error';
+} };
+export default {
+    boolean: {
+        ok: () => {
+            assertOk(validate(boolean)(true));
+            assertOk(validate(boolean)(false));
+        },
+        error: () => {
+            assertError(validate(boolean)(0));
+            assertError(validate(boolean)('true'));
+            assertError(validate(boolean)(null));
+        },
+    },
+    number: {
+        ok: () => assertOk(validate(number)(42)),
+        error: () => {
+            assertError(validate(number)('42'));
+            assertError(validate(number)(42n));
+        },
+    },
+    string: {
+        ok: () => assertOk(validate(string)('hello')),
+        error: () => {
+            assertError(validate(string)(42));
+            assertError(validate(string)(null));
+        },
+    },
+    bigint: {
+        ok: () => assertOk(validate(bigint)(4n)),
+        error: () => {
+            assertError(validate(bigint)(4));
+            assertError(validate(bigint)('4'));
+        },
+    },
+    unknown: {
+        ok: () => {
+            assertOk(validate(unknown)(null));
+            assertOk(validate(unknown)(42));
+            assertOk(validate(unknown)('hello'));
+            assertOk(validate(unknown)(true));
+            assertOk(validate(unknown)({}));
+            assertOk(validate(unknown)([]));
+        },
+    },
+    const: {
+        null: {
+            ok: () => assertOk(validate(null)(null)),
+            error: () => {
+                assertError(validate(null)(undefined));
+                assertError(validate(null)(0));
+            },
+        },
+        undefined: {
+            ok: () => assertOk(validate(undefined)(undefined)),
+            error: () => assertError(validate(undefined)(null)),
+        },
+        number: {
+            ok: () => assertOk(validate(42)(42)),
+            error: () => assertError(validate(42)(43)),
+        },
+        string: {
+            ok: () => assertOk(validate('hello')('hello')),
+            error: () => assertError(validate('hello')('world')),
+        },
+        bigint: {
+            ok: () => assertOk(validate(7n)(7n)),
+            error: () => assertError(validate(7n)(8n)),
+        },
+        boolean: {
+            ok: () => assertOk(validate(true)(true)),
+            error: () => assertError(validate(true)(false)),
+        },
+        tuple: {
+            ok: () => assertOk(validate([42, 'hello'])([42, 'hello'])),
+            extraItems: () => assertOk(validate([42])([42, 'extra'])),
+            error: () => {
+                assertError(validate([42])([99]));
+                assertError(validate([42])({}));
+            },
+        },
+        struct: {
+            ok: () => assertOk(validate({ a: 42, b: 'hello' })({ a: 42, b: 'hello' })),
+            extraKeys: () => assertOk(validate({ a: 42 })({ a: 42, b: 'extra' })),
+            error: () => {
+                assertError(validate({ a: 42 })({ a: 99 }));
+                assertError(validate({ a: 42 })([]));
+            },
+        },
+    },
+    array: {
+        empty: () => assertOk(validate(array(number))([])),
+        ok: () => assertOk(validate(array(number))([1, 2, 3])),
+        error: () => {
+            assertError(validate(array(number))([1, 'two', 3]));
+            assertError(validate(array(number))({}));
+            assertError(validate(array(number))(null));
+        },
+        nested: () => {
+            assertOk(validate(array(array(boolean)))([[true, false], [false]]));
+            assertError(validate(array(array(boolean)))([[true, 42]]));
+        },
+    },
+    record: {
+        empty: () => assertOk(validate(record(number))({})),
+        ok: () => assertOk(validate(record(string))({ a: 'hello', b: 'world' })),
+        error: () => {
+            assertError(validate(record(number))({ a: 1, b: 'two' }));
+            assertError(validate(record(number))(null));
+            assertError(validate(record(number))([]));
+        },
+    },
+    constThunk: {
+        primitive: () => {
+            assertOk(validate(() => ['const', 7n])(7n));
+            assertError(validate(() => ['const', 7n])(8n));
+        },
+    },
+    recursive: {
+        arrayOfArrays: () => {
+            // self-referential schema: an array whose elements are also arrays of the same type
+            const list = () => ['array', list];
+            // @ts-ignore see issue # 127
+            assertOk(validate(list)([]));
+            assertOk(validate(list)([[], []]));
+            assertOk(validate(list)([[[], []], []]));
+            assertError(validate(list)([42]));
+            assertError(validate(list)(null));
+        },
+        recordOfRecords: () => {
+            const tree = () => ['record', tree];
+            assertOk(validate(tree)({}));
+            assertOk(validate(tree)({ a: {}, b: { c: {} } }));
+            assertError(validate(tree)({ a: 42 }));
+        },
+    },
+};

package/types/ts/module.f.d.ts

@@ -0,0 +1,2 @@
+export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
+export type Assert<T extends true> = T;

package/types/ts/module.f.js

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