functionalscript 0.33.0 → 0.35.0

package/fs/bnf/descent/module.f.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Recursive descent matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fs/bnf/data`, this is a sibling of the
+ * LL(1) dispatch builder (`fs/bnf/ll1`). It walks the grammar by recursive
+ * descent and preserves per-code-point metadata, producing a metadata-aware
+ * AST ({@link AstRuleMeta}). It also exposes {@link createEmptyTagMap}, which
+ * records whether each rule can match the empty input.
+ *
+ * @module
+ */
+import { type CodePoint } from '../../text/utf16/module.f.ts';
+import { type StringMap } from '../../types/object/module.f.ts';
+import { type RuleSet } from '../data/module.f.ts';
+import { type Rule as FRule } from '../module.f.ts';
+type EmptyTagEntry = string | boolean;
+type EmptyTagMap = StringMap<string, EmptyTagEntry>;
+export type AstTag = string | true | undefined;
+/**
+ * Recursive descent matcher for a single named rule.
+ */
+export type DescentMatchRule<T> = (name: string, tag: AstTag, s: readonly CodePointMeta<T>[], idx: number) => DescentMatchResult<T>;
+/**
+ * Result tuple of a descent match operation: AST node, success flag, and next index.
+ */
+export type DescentMatchResult<T> = readonly [AstRuleMeta<T>, boolean, number];
+/**
+ * Entry-point recursive descent matcher.
+ */
+export type DescentMatch<T> = (name: string, s: readonly CodePointMeta<T>[]) => DescentMatchResult<T>;
+/**
+ * Code point value paired with metadata.
+ */
+export type CodePointMeta<T> = readonly [CodePoint, T];
+/**
+ * AST sequence for the metadata-aware parser.
+ */
+export type AstSequenceMeta<T> = readonly (AstRuleMeta<T> | CodePointMeta<T>)[];
+/**
+ * Metadata-aware AST node.
+ */
+export type AstRuleMeta<T> = {
+    readonly tag: AstTag;
+    readonly sequence: AstSequenceMeta<T>;
+};
+/**
+ * Creates a map that describes whether each rule can consume empty input and,
+ * for tagged variants, which tag represents the empty match.
+ */
+export declare const createEmptyTagMap: (data: readonly [RuleSet, string]) => EmptyTagMap;
+/**
+ * Creates a recursive descent parser that preserves metadata for each consumed
+ * code point.
+ */
+export declare const descentParser: <T>(fr: FRule) => DescentMatch<T>;
+export {};

package/fs/bnf/descent/module.f.js

@@ -0,0 +1,119 @@
+/**
+ * Recursive descent matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fs/bnf/data`, this is a sibling of the
+ * LL(1) dispatch builder (`fs/bnf/ll1`). It walks the grammar by recursive
+ * descent and preserves per-code-point metadata, producing a metadata-aware
+ * AST ({@link AstRuleMeta}). It also exposes {@link createEmptyTagMap}, which
+ * records whether each rule can match the empty input.
+ *
+ * @module
+ */
+import {} from "../../text/utf16/module.f.js";
+import { rangeDecode } from "../module.f.js";
+import { contains as rangeContains } from "../../types/range/module.f.js";
+import { definedEntries } from "../../types/object/module.f.js";
+import { toData } from "../data/module.f.js";
+import {} from "../module.f.js";
+const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
+    if (name in map) {
+        return [ruleSet, map, map[name]];
+    }
+    const rule = ruleSet[name];
+    if (typeof rule === 'number') {
+        return [ruleSet, { ...map, [name]: false }, false];
+    }
+    else if (rule instanceof Array) {
+        map = { ...map, [name]: true };
+        let emptyTag = rule.length == 0;
+        for (const item of rule) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (emptyTag === false) {
+                emptyTag = itemEmptyTag !== false;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+    else {
+        map = { ...map, [name]: true };
+        const entries = definedEntries(rule);
+        let emptyTag = false;
+        for (const [tag, item] of entries) {
+            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
+            map = newMap;
+            if (itemEmptyTag !== false) {
+                emptyTag = tag;
+            }
+        }
+        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
+    }
+};
+/**
+ * Creates a map that describes whether each rule can consume empty input and,
+ * for tagged variants, which tag represents the empty match.
+ */
+export const createEmptyTagMap = (data) => {
+    return emptyTagMapAdd(data[0])({})(data[1])[1];
+};
+/**
+ * Creates a recursive descent parser that preserves metadata for each consumed
+ * code point.
+ */
+export const descentParser = (fr) => {
+    const data = toData(fr);
+    const emptyTagMap = createEmptyTagMap(data);
+    const getEmptyTag = (name) => {
+        const res = emptyTagMap[name];
+        return res === false ? undefined : res;
+    };
+    const f = (name, tag, cp, idx) => {
+        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
+        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
+        const rule = data[0][name];
+        if (typeof rule === 'number') {
+            const emptyTag = getEmptyTag(name);
+            if (idx >= cp.length) {
+                return emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
+            }
+            const cpi = cp[idx];
+            const range = rangeDecode(rule);
+            if (rangeContains(range)(cpi[0])) {
+                return mrSuccess(tag, [cpi], idx + 1);
+            }
+            return mrFail(emptyTag, [], idx);
+        }
+        else if (rule instanceof Array) {
+            let seq = [];
+            let tidx = idx;
+            for (const item of rule) {
+                const m = f(item, undefined, cp, tidx);
+                const [astRule, success, nidx] = m;
+                tidx = nidx;
+                if (success === false) {
+                    return mrFail(tag, [], idx);
+                }
+                seq = [...seq, astRule];
+            }
+            return mrSuccess(tag, seq, tidx);
+        }
+        else {
+            const entries = definedEntries(rule);
+            const emptyTag = getEmptyTag(name);
+            let emptyResult = mrFail(emptyTag, [], idx);
+            for (const [tag, item] of entries) {
+                const m = f(item, tag, cp, idx);
+                if (m[1]) {
+                    if (idx !== m[2])
+                        return m;
+                    emptyResult = m;
+                }
+            }
+            return emptyResult;
+        }
+    };
+    const match = (name, cp) => {
+        return f(name, undefined, cp, 0);
+    };
+    return match;
+};

package/fs/bnf/descent/proof.f.d.ts

@@ -0,0 +1,5 @@
+export declare const proof: {
+    emptyTags: (() => void)[];
+    descentParser: (() => void)[];
+    descentParserWithMeta: (() => void)[];
+};

package/fs/bnf/descent/proof.f.js

@@ -0,0 +1,296 @@
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { commaJoin0Plus, option, range, repeat0Plus, set } from "../module.f.js";
+import { deterministic } from "../testlib.f.js";
+import { toData } from "../data/module.f.js";
+import { createEmptyTagMap, descentParser } 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 const proof = {
+    emptyTags: [
+        () => {
+            const stringRule = 'true';
+            const data = toData(stringRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const data = toData(terminalRangeRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false' };
+            const data = toData(varintRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":false,"6":false,"7":false,"8":false,"9":false,"":false}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const data = toData(emptyRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"":true}') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const varintRule = { true: 'true', e: emptyRule };
+            const data = toData(varintRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"":"e"}') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'));
+            const data = toData(repeatRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":"none","1":false,"2":false,"3":true,"r":"none","":true}') {
+                throw result;
+            }
+        },
+        () => {
+            const repeatRule = repeat0Plus(set(' \n\r\t'));
+            const data = toData(repeatRule);
+            const emptyTags = createEmptyTagMap(data);
+            const result = JSON.stringify(emptyTags);
+            if (result !== '{"0":false,"1":false,"2":false,"3":false,"4":false,"5":true,"r":"none","":true}') {
+                throw result;
+            }
+        }
+    ],
+    descentParser: [
+        () => {
+            const emptyRule = '';
+            const m = descentParser(emptyRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const m = descentParser(emptyRule);
+            const mr = descentParserCpOnly(m, "", [65, 70]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = descentParser(terminalRangeRule);
+            const mr = descentParserCpOnly(m, "", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[[65,null]]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const terminalRangeRule = range('AF');
+            const m = descentParser(terminalRangeRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [65]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"a","sequence":[[65,null]]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = descentParser(variantRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const variantRule = { 'e': emptyRule, 'a': range('AA') };
+            const m = descentParser(variantRule);
+            const mr = descentParserCpOnly(m, "", [64]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"tag":"e","sequence":[]},true,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = descentParser(stringRule);
+            const mr = descentParserCpOnly(m, "", [65, 66]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"sequence":[[65,null]]},{"sequence":[[66,null]]}]},true,2]') {
+                throw result;
+            }
+        },
+        () => {
+            const stringRule = 'AB';
+            const m = descentParser(stringRule);
+            const mr = descentParserCpOnly(m, "", [65, 67]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = descentParserCpOnly(m, "", [50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"none","sequence":[]},{"sequence":[[50,null]]}]},true,1]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = descentParserCpOnly(m, "", [45, 50]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"minus","sequence":[[45,null]]},{"sequence":[[50,null]]}]},true,2]') {
+                throw result;
+            }
+        },
+        () => {
+            const emptyRule = '';
+            const minursRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minursRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = m("", []);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[]},false,0]') {
+                throw result;
+            }
+        },
+        () => {
+            const m = descentParser(option('a'));
+            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 mr;
+                }
+            };
+            expect('a', true);
+            expect('', true);
+            expect('aa', false);
+            expect('b', false);
+        },
+        () => {
+            const ws = repeat0Plus(set(' \n\r\t'));
+            const cj = commaJoin0Plus(ws);
+            const value = () => ({
+                object: cj('{}', 'a'),
+                array: cj('[]', 'a')
+            });
+            value.name; //bun will fail if no usage of name found
+            const m = descentParser(value);
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, 'value', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('', false);
+            expect('[]', true);
+            expect('[a]', true);
+            expect('[a, a]', true);
+            expect('{a}', true);
+        },
+        () => {
+            const m = descentParser(deterministic());
+            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 mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', false);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', false);
+            expect('   -56.7e+5   3', false);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', false);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', false);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', false);
+        }
+    ],
+    descentParserWithMeta: [
+        () => {
+            const emptyRule = '';
+            const minusRule = range('--');
+            const optionalMinusRule = { 'none': emptyRule, 'minus': minusRule };
+            const digitRule = range('09');
+            const numberRule = [optionalMinusRule, digitRule];
+            const m = descentParser(numberRule);
+            const mr = m("", [[45, 'minus'], [50, 'two']]);
+            const result = JSON.stringify(mr);
+            if (result !== '[{"sequence":[{"tag":"minus","sequence":[[45,"minus"]]},{"sequence":[[50,"two"]]}]},true,2]') {
+                throw result;
+            }
+        },
+    ],
+};

package/fs/bnf/ll1/module.f.d.ts

@@ -0,0 +1,72 @@
+/**
+ * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fs/bnf/data`, this is one member of the
+ * family of automaton builders that consume a {@link RuleSet}: it compiles the
+ * grammar into a predictive {@link dispatchMap} and matches input into an AST
+ * ({@link MatchResult}). It throws at build time (`can not merge …`) when the
+ * grammar is not LL(1) — a first/first conflict.
+ *
+ * @module
+ */
+import { type CodePoint } from '../../text/utf16/module.f.ts';
+import { type RangeMapArray } from '../../types/range_map/module.f.ts';
+import { type StringMap } from '../../types/object/module.f.ts';
+import { type RuleSet } from '../data/module.f.ts';
+import { type Rule as FRule } from '../module.f.ts';
+type EmptyTag = string | true | undefined;
+type DispatchRule = {
+    readonly emptyTag: EmptyTag;
+    readonly rangeMap: Dispatch;
+};
+type Dispatch = RangeMapArray<DispatchResult>;
+type DispatchResult = DispatchRuleCollection | null;
+type DispatchRuleOrName = DispatchRule | string;
+type DispatchRuleCollection = {
+    readonly tag: string | undefined;
+    readonly rules: DispatchRuleOrName[];
+};
+type DispatchMap = StringMap<string, DispatchRule>;
+/**
+ * Represents a parsed AST sequence.
+ */
+export type AstSequence = readonly (AstRule | CodePoint)[];
+export type AstTag = string | true | undefined;
+/**
+ * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
+ */
+type AstRule = {
+    readonly tag: AstTag;
+    readonly sequence: AstSequence;
+};
+/**
+ * Represents the remaining input after a match attempt, or `null` if no match is possible.
+ */
+export type Remainder = readonly CodePoint[] | null;
+/**
+ * Parsing result of {@link parser} and {@link parserRuleSet}.
+ *
+ * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
+ */
+export type MatchResult = readonly [AstRule, boolean, Remainder];
+/**
+ * LL(1) parser function for matching by rule name.
+ */
+export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
+/**
+ * Internal match function signature used by compiled dispatch rules.
+ */
+export type MatchRule = (dr: DispatchRule, s: readonly CodePoint[]) => MatchResult;
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ */
+export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ */
+export declare const parser: (fr: FRule) => Match;
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ */
+export declare const parserRuleSet: (ruleSet: RuleSet) => Match;
+export {};