functionalscript 0.12.0 → 0.12.2

package/djs/serializer/test.f.d.ts

@@ -6,20 +6,20 @@ declare const _default: {
         testSort?: never;
         testIdentity?: never;
     } | {
-        testSort: () => void;
-        testIdentity: () => void;
         testPrimitives?: never;
         testArray?: never;
         testObj?: never;
+        testSort: () => void;
+        testIdentity: () => void;
     })[];
     stringifyAsTree: ({
         sort: () => void;
         identity: () => void;
         stringify?: never;
     } | {
-        stringify: () => void;
         sort?: never;
         identity?: never;
+        stringify: () => void;
     })[];
 };
 export default _default;

package/json/module.f.js

@@ -60,7 +60,3 @@ export const serialize = sort => {
  */
 export const stringify = sort => compose(serialize(sort))(concat);
 export const parse = JSON.parse;
-/*
-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.12.0",
+  "version": "0.12.2",
   "type": "module",
   "files": [
     "**/*.js",

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

@@ -1,46 +1,9 @@
-/**
- * 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.
- */
-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;
+export type Const = null | boolean | number | string | undefined | bigint | {
+    readonly [K in string]: Type;
+} | readonly Type[];
+export type ConstObject = Struct | Tuple;
 /** A struct schema: plain object whose values are nested `Type`s. */
 export type Struct = {
     readonly [K in string]: Type;
@@ -53,18 +16,9 @@ export declare const tag0List: readonly ["bigint", "boolean", "number", "string"
 /** 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];
-/**
- * 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 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;
+export type Info0<T extends Tag0> = T extends Tag0 ? readonly [T] : never;
 /** Any schema: a `Const` used directly, or a `Thunk` for tag-based/recursive schemas. */
-export type Type = Const | Thunk;
+export type Type = (() => (readonly ['const', Const] | readonly ['bigint'] | readonly ['boolean'] | readonly ['number'] | readonly ['string'] | readonly ['unknown'] | readonly ['array', Type] | readonly ['record', Type] | readonly ['or', ...readonly Type[]])) | Const;
 /** The type of a nullary thunk for `Tag0`. */
 type Type0<T extends Tag0> = () => Info0<T>;
 /** Schema type for `boolean`. */
@@ -92,7 +46,7 @@ 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];
+export type Info1<K extends Tag1, T extends Type> = K extends Tag1 ? readonly [K, T] : never;
 /** 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>;
@@ -104,4 +58,8 @@ export declare const array: MakeType1<'array'>;
 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'>;
+/** Schema type for a union of types `T`. */
+export type Or<T extends readonly Type[]> = () => readonly ['or', ...T];
+/** Constructs a schema that validates a value matching any of the given schemas. */
+export declare const or: <T extends readonly Type[]>(...types: T) => Or<T>;
 export {};

package/types/rtti/module.f.js

@@ -19,3 +19,5 @@ const type1 = (key) => t => () => [key, t];
 export const array = type1('array');
 /** Constructs a schema that validates `{ readonly[K in string]: Ts<T> }`. */
 export const record = type1('record');
+/** Constructs a schema that validates a value matching any of the given schemas. */
+export const or = (...types) => () => ['or', ...types];

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

@@ -1,23 +1,24 @@
-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 { Unknown as DjsUnknown } from '../../../djs/module.f.ts';
+import type { Tag0, Tag1, Struct, Tuple, 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;
+export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends {
+    readonly [k in string]: Type;
+} ? {
+    readonly [K in keyof T]: Ts<T[K]>;
+} : T;
 /** 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> = {
+/** Maps a tuple schema to a readonly tuple of resolved types. */
+export type TupleTs<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]>;
@@ -36,4 +37,6 @@ export type StructTs<T extends Struct> = {
  * 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;
+export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly ['const', infer C] ? ConstTs<C> : I extends readonly ['boolean'] ? boolean : I extends readonly ['number'] ? number : I extends readonly ['string'] ? string : I extends readonly ['bigint'] ? bigint : I extends readonly ['unknown'] ? DjsUnknown : I extends readonly ['array', infer E extends Type] ? readonly Ts<E>[] : I extends readonly ['record', infer E extends Type] ? {
+    readonly [K in string]: Ts<E>;
+} : I extends readonly ['or', ...infer A extends readonly Type[]] ? Ts<A[number]> : never) : ConstTs<T>;

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

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

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

@@ -3,6 +3,7 @@ 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";
+import { todo } from "../../../dev/module.f.js";
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
@@ -36,20 +37,6 @@ const tag1Validate = ([tag, item]) => tag === 'array'
     : 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
@@ -80,6 +67,18 @@ const constPrimitiveValidate = (rtti) => value => rtti === value
 const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
     ? constObjectValidate(rtti)
     : constPrimitiveValidate(rtti);
+const orValidate = (rtti) => {
+    const all = rtti.map(r => validate(r));
+    return value => {
+        for (const i of all) {
+            const r = i(value);
+            if (r[0] === 'ok') {
+                return r;
+            }
+        }
+        return error('no match');
+    };
+};
 /**
  * Creates a validator function for the given RTTI schema.
  *
@@ -95,6 +94,17 @@ const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
  * v(['a', 'b'])  // ['error', 'unexpected value']
  * ```
  */
-export const validate = (rtti) => typeof rtti === 'function'
-    ? thunkValidate(rtti)
-    : constValidate(rtti);
+export const validate = (rtti) => {
+    if (typeof rtti === 'function') {
+        const [tag, ...value] = rtti();
+        switch (tag) {
+            case 'const': return constValidate(value[0]);
+            case 'array': return arrayValidate(value[0]);
+            case 'record': return recordValidate(value[0]);
+            case 'unknown': return ok;
+            case 'or': return orValidate(value);
+        }
+        return primitive0Validate(tag);
+    }
+    return constValidate(rtti);
+};

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

@@ -68,6 +68,20 @@ declare const _default: {
     constThunk: {
         primitive: () => void;
     };
+    or: {
+        consts: {
+            ok: () => void;
+            error: () => void;
+        };
+        thunks: {
+            ok: () => void;
+            error: () => void;
+        };
+        mixed: {
+            ok: () => void;
+            error: () => void;
+        };
+    };
     recursive: {
         arrayOfArrays: () => void;
         recordOfRecords: () => void;

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

@@ -1,5 +1,5 @@
 import { validate } from "./module.f.js";
-import { boolean, number, string, bigint, unknown, array, record } from "../module.f.js";
+import { boolean, number, string, bigint, unknown, array, record, or } from "../module.f.js";
 const assertOk = ([k]) => { if (k !== 'ok') {
     throw 'expected ok';
 } };
@@ -19,21 +19,27 @@ export default {
         },
     },
     number: {
-        ok: () => assertOk(validate(number)(42)),
+        ok: () => {
+            assertOk(validate(number)(42));
+        },
         error: () => {
             assertError(validate(number)('42'));
             assertError(validate(number)(42n));
         },
     },
     string: {
-        ok: () => assertOk(validate(string)('hello')),
+        ok: () => {
+            assertOk(validate(string)('hello'));
+        },
         error: () => {
             assertError(validate(string)(42));
             assertError(validate(string)(null));
         },
     },
     bigint: {
-        ok: () => assertOk(validate(bigint)(4n)),
+        ok: () => {
+            assertOk(validate(bigint)(4n));
+        },
         error: () => {
             assertError(validate(bigint)(4));
             assertError(validate(bigint)('4'));
@@ -51,34 +57,49 @@ export default {
     },
     const: {
         null: {
-            ok: () => assertOk(validate(null)(null)),
+            ok: () => {
+                assertOk(validate(null)(null));
+            },
             error: () => {
                 assertError(validate(null)(undefined));
                 assertError(validate(null)(0));
             },
         },
         undefined: {
-            ok: () => assertOk(validate(undefined)(undefined)),
+            ok: () => {
+                assertOk(validate(undefined)(undefined));
+            },
             error: () => assertError(validate(undefined)(null)),
         },
         number: {
-            ok: () => assertOk(validate(42)(42)),
+            ok: () => {
+                assertOk(validate(42)(42));
+            },
             error: () => assertError(validate(42)(43)),
         },
         string: {
-            ok: () => assertOk(validate('hello')('hello')),
+            ok: () => {
+                assertOk(validate('hello')('hello'));
+            },
             error: () => assertError(validate('hello')('world')),
         },
         bigint: {
-            ok: () => assertOk(validate(7n)(7n)),
+            ok: () => {
+                assertOk(validate(7n)(7n));
+            },
             error: () => assertError(validate(7n)(8n)),
         },
         boolean: {
-            ok: () => assertOk(validate(true)(true)),
+            ok: () => {
+                assertOk(validate(true)(true));
+            },
             error: () => assertError(validate(true)(false)),
         },
         tuple: {
-            ok: () => assertOk(validate([42, 'hello'])([42, 'hello'])),
+            ok: () => {
+                const t = [42, 'hello'];
+                assertOk(validate(t)([42, 'hello']));
+            },
             extraItems: () => assertOk(validate([42])([42, 'extra'])),
             error: () => {
                 assertError(validate([42])([99]));
@@ -86,7 +107,10 @@ export default {
             },
         },
         struct: {
-            ok: () => assertOk(validate({ a: 42, b: 'hello' })({ a: 42, b: 'hello' })),
+            ok: () => {
+                const t = { a: 42, b: 'hello' };
+                assertOk(validate(t)({ a: 42, b: 'hello' }));
+            },
             extraKeys: () => assertOk(validate({ a: 42 })({ a: 42, b: 'extra' })),
             error: () => {
                 assertError(validate({ a: 42 })({ a: 99 }));
@@ -96,20 +120,27 @@ export default {
     },
     array: {
         empty: () => assertOk(validate(array(number))([])),
-        ok: () => assertOk(validate(array(number))([1, 2, 3])),
+        ok: () => {
+            const t = array(number);
+            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: () => {
+            const t = array(array(boolean));
             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' })),
+        ok: () => {
+            const t = record(string);
+            assertOk(validate(t)({ a: 'hello', b: 'world' }));
+        },
         error: () => {
             assertError(validate(record(number))({ a: 1, b: 'two' }));
             assertError(validate(record(number))(null));
@@ -118,26 +149,69 @@ export default {
     },
     constThunk: {
         primitive: () => {
-            assertOk(validate(() => ['const', 7n])(7n));
-            assertError(validate(() => ['const', 7n])(8n));
+            const t = () => ['const', 7n];
+            assertOk(validate(t)(7n));
+            assertError(validate(t)(8n));
+        },
+    },
+    or: {
+        consts: {
+            ok: () => {
+                const t = or(...[false, 42, 'hello']);
+                assertOk(validate(t)(false));
+                assertOk(validate(t)(42));
+                assertOk(validate(t)('hello'));
+            },
+            error: () => {
+                const t = or(...[false, 42, 'hello']);
+                assertError(validate(t)(true));
+                assertError(validate(t)(43));
+                assertError(validate(t)('world'));
+                assertError(validate(t)(null));
+            },
+        },
+        thunks: {
+            ok: () => {
+                const t = or(number, string);
+                assertOk(validate(t)(42));
+                assertOk(validate(t)('hello'));
+            },
+            error: () => {
+                const t = or(number, string);
+                assertError(validate(t)(true));
+                assertError(validate(t)(null));
+            },
+        },
+        mixed: {
+            ok: () => {
+                const t = or(42, string);
+                assertOk(validate(t)(42));
+                assertOk(validate(t)('hello'));
+            },
+            error: () => {
+                const t = or(42, string);
+                assertError(validate(t)(43));
+                assertError(validate(t)(null));
+            },
         },
     },
     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));
+            const v = validate(list);
+            assertOk(v([]));
+            assertOk(v([[], []]));
+            assertOk(v([[[], []], []]));
+            assertError(v([42]));
+            assertError(v(null));
         },
         recordOfRecords: () => {
             const tree = () => ['record', tree];
-            assertOk(validate(tree)({}));
-            assertOk(validate(tree)({ a: {}, b: { c: {} } }));
-            assertError(validate(tree)({ a: 42 }));
+            const v = validate(tree);
+            assertOk(v({}));
+            assertOk(v({ a: {}, b: { c: {} } }));
+            assertError(v({ a: 42 }));
         },
     },
 };