functionalscript 0.13.1 → 0.14.1

package/djs/parser-new/test.f.js

@@ -1,202 +0,0 @@
-import { descentParser } from "../../bnf/data/module.f.js";
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-import { jsGrammar } from "./module.f.js";
-const mapCodePoint = (cp) => [cp, undefined];
-const descentParserCpOnly = (m, name, cp) => {
-    const cpm = toArray(map(mapCodePoint)(cp));
-    return m(name, cpm);
-};
-export default {
-    isValid: [() => {
-            const m = descentParser(jsGrammar());
-            const expect = (s, expected) => {
-                const cp = toArray(stringToCodePointList(s));
-                const mr = descentParserCpOnly(m, '', cp);
-                const success = mr[1] && mr[2] === cp.length;
-                if (success !== expected) {
-                    throw JSON.stringify([s, mr]);
-                }
-            };
-            expect('"', false);
-            expect('   true   ', true);
-            expect('   tr2ue   ', true);
-            expect('   2true   ', true);
-            expect('   true"   ', false);
-            expect('   "Hello"   ', true);
-            expect('   "Hello   ', false);
-            expect('   "Hello\\n\\r\\""   ', true);
-            expect('   56.7e+5  ', true);
-            expect('   -56.7e+5  ', true);
-            expect('   h-56.7e+5   ', true);
-            expect('   -56.7e+5   3', true);
-            expect('   [] ', true);
-            expect('   {} ', true);
-            expect('   [[[]]] ', true);
-            expect('   [1] ', true);
-            expect('   [ 12, false, "a"]  ', true);
-            expect('   [ 12, false2, "a"]  ', true);
-            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
-            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
-            expect('   { "q": [ 12, false, [}], "a"] }  ', true);
-            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
-            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', true);
-            expect('. + ++ +=', true);
-            expect('//12\n', true);
-            expect('/*12*/', true);
-            expect('/* 1*2 */', true);
-        }
-    ],
-    parser: [
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('tr'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'id')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('"tr"'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'string')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('56.7e+5'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'number')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('56n'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'number')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('*'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '*')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('**'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '**')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('=>'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '=>')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('=='));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '==')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('==='));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '===')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('='));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '=')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList(' '));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== ' ')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('\n'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '\n')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('/\n'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== '/')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('//\n'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'comment')
-                throw JSON.stringify(mr);
-        },
-        () => {
-            const m = descentParser(jsGrammar());
-            const cp = toArray(stringToCodePointList('/*1*/'));
-            const mr = descentParserCpOnly(m, '', cp);
-            const seq = mr[0].sequence[0];
-            if (seq instanceof Array)
-                throw JSON.stringify(mr);
-            if (seq.tag !== 'comment')
-                throw JSON.stringify(mr);
-        }
-    ]
-};

package/types/rtti/module.f.js

@@ -1,27 +0,0 @@
-import { includes } from "../array/module.f.js";
-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');
-/** Constructs a schema that validates a value matching any of the given schemas. */
-export const or = (...types) => () => ['or', ...types];
-/** Constructs a schema that validates a value matching `T` or `undefined`. */
-export const option = (t) => or(t, undefined);
-/** Schema that never matches any value — the empty union, corresponding to TypeScript's `never`. */
-export const never = or();

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

@@ -1,6 +0,0 @@
-declare const _default: {
-    typeof: {
-        [k: string]: (() => void)[];
-    };
-};
-export default _default;

package/types/rtti/test.f.js

@@ -1,22 +0,0 @@
-const tests = {
-    undefined: [undefined],
-    boolean: [true, false],
-    string: ['hello'],
-    number: [3],
-    bigint: [4n],
-    object: [null, {}, []],
-    function: [() => undefined]
-};
-const assertOk = ([k]) => { if (k !== 'ok') {
-    throw 'expected ok';
-} };
-const assertError = ([k]) => { if (k !== 'error') {
-    throw 'expected error';
-} };
-export default {
-    typeof: Object.fromEntries(Object.entries(tests).map(([k, a]) => [k, a.map(v => () => {
-            if (typeof v !== k) {
-                throw `typeof ${v} !== ${k}`;
-            }
-        })])),
-};

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

@@ -1,50 +0,0 @@
-/**
- * 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>;