functionalscript 0.12.1 → 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.1",
+  "version": "0.12.2",
   "type": "module",
   "files": [
     "**/*.js",

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

@@ -17,17 +17,8 @@ export declare const tag0List: readonly ["bigint", "boolean", "number", "string"
 export type Tag0 = typeof tag0List[number];
 /** Info tuple for a nullary tag: `readonly[tag]`. */
 export type Info0<T extends Tag0> = T extends Tag0 ? readonly [T] : never;
-/**
- * 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;
 /** Any schema: a `Const` used directly, or a `Thunk` for tag-based/recursive schemas. */
-export type Type = (() => (readonly ['const', Const] | readonly ['bigint'] | readonly ['boolean'] | readonly ['number'] | readonly ['string'] | readonly ['unknown'] | readonly ['array', Type] | readonly ['record', Type])) | Const;
+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`. */
@@ -67,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,5 +1,5 @@
 import type { 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 { 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;
@@ -11,8 +11,6 @@ export type ConstTs<T> = T extends readonly Type[] ? TupleTs<T> : T extends {
 } : 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> }`. */
@@ -41,4 +39,4 @@ export type StructTs<T extends Struct> = {
  */
 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>;
-} : never) : ConstTs<T>;
+} : I extends readonly ['or', ...infer A extends readonly Type[]] ? Ts<A[number]> : never) : ConstTs<T>;

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.
  *
@@ -97,12 +96,13 @@ const constValidate = (rtti) => typeof rtti === 'object' && rtti !== null
  */
 export const validate = (rtti) => {
     if (typeof rtti === 'function') {
-        const [tag, value] = rtti();
+        const [tag, ...value] = rtti();
         switch (tag) {
-            case 'const': return constValidate(value);
-            case 'array': return arrayValidate(value);
-            case 'record': return recordValidate(value);
+            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);
     }

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';
 } };
@@ -154,6 +154,47 @@ export default {
             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