functionalscript 0.43.0 → 0.44.0

package/fjs/bnf/descent/proof.f.mjs

@@ -0,0 +1,351 @@
+/**
+ * @module
+ *
+ * @import { CodePoint } from '../../text/utf16/types.ts'
+ * @import { DescentMatch, CodePointMeta, DescentMatchResult } from './types.ts'
+ */
+
+import { stringToCodePointList } from '../../text/utf16/module.f.mjs'
+import { map, toArray } from '../../types/list/module.f.mjs'
+import { commaJoin0Plus, option, range, repeat0Plus, set } from '../module.f.mjs'
+import { emptyTagMap, toData } from '../data/module.f.mjs'
+import { descentParser } from './module.f.mjs'
+import { assertEq, assertNotNullish } from '../../asserts/module.f.mjs'
+import { deterministic } from '../testlib.f.mjs'
+
+/** @type {(cp: CodePoint) => CodePointMeta<unknown>} */
+const mapCodePoint = cp => [cp, undefined]
+
+/**
+ * The code point of a one-character string, for expectations that would
+ * otherwise spell it as a bare number. Goes through the module's own
+ * conversion, the same one that builds the parser's input.
+ *
+ * @type {(s: string) => CodePoint}
+ */
+const cp1 = s => toArray(stringToCodePointList(s))[0]
+
+/** @type {(m: DescentMatch<unknown>, name: string, cp: readonly CodePoint[]) => DescentMatchResult<unknown>} */
+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 = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const terminalRangeRule = range('AF')
+            const data = toData(terminalRangeRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const varintRule = { true: 'true', false: 'false'}
+            const data = toData(varintRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const data = toData(emptyRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"":true}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const varintRule = { true: 'true', e: emptyRule}
+            const data = toData(varintRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"5":true,"":"e"}') { throw result }
+        },
+        () => {
+            const repeatRule = repeat0Plus(option('a'))
+            const data = toData(repeatRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"0":"none","3":true,"":true,"r":"none"}') { throw result }
+        },
+        () => {
+            const repeatRule = repeat0Plus(set(' \n\r\t'))
+            const data = toData(repeatRule)
+            const emptyTags = emptyTagMap(data[0])
+            const result = JSON.stringify(emptyTags)
+            if (result !== '{"5":true,"r":"none"}') { throw result }
+        }
+    ],
+    descentParser: [
+        () => {
+            const emptyRule = ''
+            const m = descentParser(emptyRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const m = descentParser(emptyRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AF')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            // Literal code point on purpose. Elsewhere both sides of the
+            // assertion come from `stringToCodePointList` — the input is built
+            // with it and the expectation interpolates `cp1`, which calls it
+            // too — so a change to the conversion would move both sides
+            // together and the test would still pass. Pinning `A` to 65 here
+            // covers the conversion itself.
+            const terminalRangeRule = range('AF')
+            const m = descentParser(terminalRangeRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('A')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"sequence":[[65,null]]},"success":true,"idx":1}') { throw result }
+        },
+        () => {
+            const terminalRangeRule = range('AF')
+            const m = descentParser(terminalRangeRule)
+            const mr =descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('AF')}]}}`) { throw result }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('A')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"tag":"a","sequence":[[${cp1('A')},null]]},"success":true,"idx":1}`) { throw result }
+        },
+        () => {
+            const variantRule = { 'a': range('AA'), 'b': range('BB')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            // Both branches were rejected at 0, so both terminals are expected there.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('AA')},${range('BB')}]}}`) { 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 !== '{"ast":{"tag":"e","sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyRule = ''
+            const variantRule = { 'e': emptyRule, 'a': range('AA')}
+            const m = descentParser(variantRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('@')))
+            const result = JSON.stringify(mr)
+            if (result !== '{"ast":{"tag":"e","sequence":[]},"success":true,"idx":0}') { throw result }
+        },
+        () => {
+            const emptyVariantRule = {}
+            const m = descentParser(emptyVariantRule)
+            const mr = m("", [])
+            const result = JSON.stringify(mr)
+            // A variant with no branches fails without ever trying a terminal,
+            // so there is nothing to expect.
+            if (result !== '{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[]}}') { throw result }
+        },
+        () => {
+            const stringRule = 'AB'
+            const m = descentParser(stringRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AB')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"sequence":[[${cp1('A')},null]]},{"sequence":[[${cp1('B')},null]]}]},"success":true,"idx":2}`) { throw result }
+        },
+        () => {
+            const stringRule = 'AB'
+            const m = descentParser(stringRule)
+            const mr = descentParserCpOnly(m, "", toArray(stringToCodePointList('AC')))
+            const result = JSON.stringify(mr)
+            // The result index rewound to the sequence's start, but the furthest
+            // failure kept the position where 'B' was actually rejected.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":1,"expected":[${range('BB')}]}}`) { 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, "", toArray(stringToCodePointList('2')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"none","sequence":[]},{"sequence":[[${cp1('2')},null]]}]},"success":true,"idx":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, "", toArray(stringToCodePointList('-2')))
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"minus","sequence":[[${cp1('-')},null]]},{"sequence":[[${cp1('2')},null]]}]},"success":true,"idx":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)
+            // Past the end: '-' and then the digit range were both rejected at 0.
+            if (result !== `{"ast":{"sequence":[]},"success":false,"idx":0,"failure":{"idx":0,"expected":[${range('--')},${range('09')}]}}`) { throw result }
+        },
+        () => {
+            const m = descentParser(option('a'))
+
+            const expect = (/** @type {string} */s, /** @type {Boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, '', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, 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 = (/** @type {string} */s, /** @type {boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, 'value', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, mr)
+            }
+
+            expect('', false)
+            expect('[]', true)
+            expect('[a]', true)
+            expect('[a, a]', true)
+            expect('{a}', true)
+        },
+        () => {
+            const m = descentParser(deterministic())
+
+            const expect = (/** @type {string} */s, /** @type {boolean} */expected) => {
+                const cp = toArray(stringToCodePointList(s))
+                const mr = descentParserCpOnly(m, '', cp)
+                const success = mr.success && mr.idx === cp.length
+                assertEq(success, expected, 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)
+        }
+    ],
+    // Regression for the stack-recursive matcher bug: the matcher used to recurse
+    // natively once per grammar step, so match depth grew with input length and these
+    // inputs threw "RangeError: Maximum call stack size exceeded" at a few thousand
+    // code points. The explicit-frame-stack matcher handles them in O(1) JS call stack.
+    longInput: [
+        () => {
+            // long right-recursive repetition: one repeat0Plus chain across the whole input
+            const rule = repeat0Plus(set(' \n\r\t'))
+            const name = toData(rule)[1]
+            const m = descentParser(rule)
+            const cp = toArray(stringToCodePointList(' '.repeat(10000)))
+            const { success: ok, idx } = descentParserCpOnly(m, name, cp)
+            assertEq(ok, true)
+            assertEq(idx, 10000)
+        },
+        () => {
+            // deep non-repetition nesting: 5000 bracket levels in the JSON-like test
+            // grammar — a shape that repetition-specific fixes (a `repeat` primitive)
+            // would not cover
+            const m = descentParser(deterministic())
+            const n = 5000
+            const cp = toArray(stringToCodePointList('['.repeat(n) + ']'.repeat(n)))
+            const { success: ok, idx } = descentParserCpOnly(m, '', cp)
+            assertEq(ok, true)
+            assertEq(idx, n * 2)
+        },
+    ],
+    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("", [[cp1('-'), 'minus'], [cp1('2'), 'two']])
+            const result = JSON.stringify(mr)
+            if (result !== `{"ast":{"sequence":[{"tag":"minus","sequence":[[${cp1('-')},"minus"]]},{"sequence":[[${cp1('2')},"two"]]}]},"success":true,"idx":2}`) { throw result }
+        },
+    ],
+    furthestFailure: [
+        () => {
+            // A branch rejected *before* the high-water mark must not pull it back:
+            // `x` gets to index 1 before failing, then `y` fails at 0.
+            const m = descentParser({ x: ['A', 'B'], y: 'B' })
+            const { success: ok, idx, failure } = descentParserCpOnly(m, '', toArray(stringToCodePointList('AC')))
+            assertEq(ok, false)
+            assertEq(idx, 0)
+            // A failed match always carries a failure; that is the contract.
+            const f = assertNotNullish(failure)
+            assertEq(f.idx, 1)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], range('BB'))
+        },
+        () => {
+            // The same terminal rejected at the same index by two branches is
+            // expected once, not twice.
+            const m = descentParser({ x: ['A', 'B'], y: ['A', 'B', 'C'] })
+            const { failure } = descentParserCpOnly(m, '', toArray(stringToCodePointList('AC')))
+            const f = assertNotNullish(failure)
+            assertEq(f.idx, 1)
+            assertEq(f.expected.length, 1)
+            assertEq(f.expected[0], range('BB'))
+        },
+    ],
+}

package/fjs/bnf/descent/types.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Types for the recursive descent matcher backend.
+ *
+ * @module
+ */
+import type { CodePoint } from '../../text/utf16/types.ts';
+import type { TerminalRange } from '../types.ts';
+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>;
+/**
+ * Where a match ran out of road, for diagnostics.
+ *
+ * `idx` is the furthest position any terminal was tried at and rejected, and
+ * `expected` holds the terminals that would have allowed progress there, in the
+ * order the grammar tried them and without repeats.
+ *
+ * Unlike a failed result's own index, this never rewinds: a failing sequence
+ * item rewinds the result to the sequence's start, while the furthest failure is
+ * a high-water mark over the whole match — including branches the grammar
+ * backtracked out of. That is what makes "expected X or Y at N" possible.
+ *
+ * `idx` is `0` with an empty `expected` when the match failed without ever
+ * rejecting a terminal, as an empty variant does.
+ */
+export type DescentFailure = {
+    readonly idx: number;
+    readonly expected: readonly TerminalRange[];
+};
+/**
+ * Result of a descent match operation.
+ *
+ * `failure` is present exactly when `success` is `false`: a successful match has
+ * nothing to diagnose, and its `idx` already says where matching stopped. Note
+ * the consequence for a match that succeeds *without consuming all input* —
+ * `idx` still locates the position it stopped at, but the terminals that would
+ * have let it continue are not reported.
+ *
+ * On failure `idx` has rewound to the start of the enclosing sequence and
+ * locates nothing; read `failure.idx` instead.
+ *
+ * The same type describes a match in progress, where `failure` is likewise
+ * absent until the match ends.
+ */
+export type DescentMatchResult<T> = {
+    readonly ast: AstRuleMeta<T>;
+    readonly success: boolean;
+    readonly idx: number;
+    readonly failure?: DescentFailure;
+};
+/**
+ * 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>;
+};

package/fjs/bnf/descent/types.js

@@ -0,0 +1,6 @@
+/**
+ * Types for the recursive descent matcher backend.
+ *
+ * @module
+ */
+export {};

package/fjs/bnf/ll1/module.f.d.mts

@@ -0,0 +1,41 @@
+/**
+ * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fjs/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. Nullability is looked up from
+ * {@link emptyTagMap} in `fjs/bnf/data` rather than re-derived here.
+ *
+ * See `./types.ts` for the type-level API.
+ *
+ * @module
+ *
+ * @import { Properties } from '../../types/range_map/types.ts'
+ * @import { StringSet } from '../../types/string_set/types.ts'
+ * @import { EmptyTag, RuleSet } from '../data/types.ts'
+ * @import { Rule as FRule } from '../types.ts'
+ * @import { AstSequence, AstTag, Match, MatchResult, MatchRule, Remainder, _Dispatch, _DispatchMap, _DispatchResult, _DispatchRule } from './types.ts'
+ */
+import type { RuleSet } from '../data/types.ts';
+import type { Rule as FRule } from '../types.ts';
+import type { Match, _DispatchMap } from './types.ts';
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ *
+ * @type {(ruleSet: RuleSet) => _DispatchMap}
+ */
+export declare const dispatchMap: (ruleSet: RuleSet) => _DispatchMap;
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ *
+ * @type {(fr: FRule) => Match}
+ */
+export declare const parser: (fr: FRule) => Match;
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ *
+ * @type {(ruleSet: RuleSet) => Match}
+ */
+export declare const parserRuleSet: (ruleSet: RuleSet) => Match;

package/fjs/bnf/ll1/module.f.mjs

@@ -0,0 +1,199 @@
+/**
+ * LL(1) dispatch/matcher backend over the BNF data {@link RuleSet}.
+ *
+ * Built from the serializable IR in `fjs/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. Nullability is looked up from
+ * {@link emptyTagMap} in `fjs/bnf/data` rather than re-derived here.
+ *
+ * See `./types.ts` for the type-level API.
+ *
+ * @module
+ *
+ * @import { Properties } from '../../types/range_map/types.ts'
+ * @import { StringSet } from '../../types/string_set/types.ts'
+ * @import { EmptyTag, RuleSet } from '../data/types.ts'
+ * @import { Rule as FRule } from '../types.ts'
+ * @import { AstSequence, AstTag, Match, MatchResult, MatchRule, Remainder, _Dispatch, _DispatchMap, _DispatchResult, _DispatchRule } from './types.ts'
+ */
+
+import { strictEqual } from '../../types/function/operator/module.f.mjs'
+import { toArray } from '../../types/list/module.f.mjs'
+import { rangeMap } from '../../types/range_map/module.f.mjs'
+import { contains, set } from '../../types/string_set/module.f.mjs'
+import { rangeDecode } from '../module.f.mjs'
+import { definedEntries } from '../../types/object/module.f.mjs'
+import { emptyTagMap, toData } from '../data/module.f.mjs'
+
+/** @type {Properties<_DispatchResult>} */
+const dispatchProps = {
+    union: a => b => {
+        if (a === null) {
+            return b
+        }
+        if (b === null) {
+            return a
+        }
+        throw ['can not merge [', a, '][', b, ']']
+    },
+    equal: strictEqual,
+    def: null,
+}
+
+const dispatchOp = rangeMap(dispatchProps)
+
+/**
+ * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
+ *
+ * @type {(ruleSet: RuleSet) => _DispatchMap}
+ */
+export const dispatchMap = ruleSet => {
+
+    const nullMap = emptyTagMap(ruleSet)
+
+    /** @type {(dr: _DispatchResult, name: string) => _DispatchResult} */
+    const addRuleToDispatch = (dr, name) => {
+        if (dr === null)
+            return null
+
+        return { tag: dr.tag, rules: [...dr.rules, name]}
+    }
+
+    /** @type {(dr: _DispatchResult, tag: string) => _DispatchResult} */
+    const addTagToDispatch = (dr, tag) => {
+        if (dr === null)
+            return null
+
+        return { tag, rules: dr.rules}
+    }
+
+    /** @type {(dm: _DispatchMap, name: string, current: StringSet) => _DispatchMap} */
+    const dispatchRule = (dm, name, current) => {
+        if (name in dm) { return dm }
+        const newCurrent = set(name)(current)
+        const rule = ruleSet[name]
+        if (typeof rule === 'number') {
+            const range = rangeDecode(rule)
+            const dispatch = dispatchOp.fromRange({tag: undefined, rules: []})(range)
+            /** @type {_DispatchRule} */
+            const dr = {emptyTag: undefined, rangeMap: dispatch}
+            return { ...dm, [name]: dr }
+        } else if (rule instanceof Array) {
+            /** @type {EmptyTag} */
+            let emptyTag = true
+            /** @type {_Dispatch} */
+            let result = []
+            for (const item of rule) {
+                if (contains(item)(newCurrent)) {
+                    result = result.map(x => [addRuleToDispatch(x[0], item), x[1]])
+                } else {
+                    dm = dispatchRule(dm, item, newCurrent)
+                    const dr = /** @type {_DispatchRule} */ (dm[item])
+                    if (emptyTag === true) {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]])
+                        result = toArray(dispatchOp.merge(result)(dr.rangeMap))
+                        emptyTag = nullMap[item] !== undefined ? true : undefined
+                    } else {
+                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]])
+                    }
+                }
+            }
+            /** @type {_DispatchRule} */
+            const dr = {emptyTag, rangeMap: result}
+            return { ...dm, [name]: dr}
+        } else {
+            const entries = definedEntries(rule)
+            /** @type {_Dispatch} */
+            let result = []
+            /** @type {EmptyTag} */
+            let emptyTag = undefined
+            for (const [tag, item] of entries) {
+                dm = dispatchRule(dm, item, newCurrent)
+                const dr = /** @type {_DispatchRule} */ (dm[item])
+                if (nullMap[item] !== undefined) {
+                    emptyTag = tag
+                } else {
+                    /** @type {_Dispatch} */
+                    const d = dr.rangeMap.map(x => [addTagToDispatch(x[0], tag), x[1]])
+                    result = toArray(dispatchOp.merge(result)(d))
+                }
+            }
+            /** @type {_DispatchRule} */
+            const dr = {emptyTag, rangeMap: result}
+            return { ...dm, [name]: dr}
+        }
+    }
+
+    /** @type {_DispatchMap} */
+    let result = {}
+    for (const k in ruleSet) {
+        result = dispatchRule(result, k, null)
+    }
+
+    return result
+}
+
+/**
+ * Creates an LL(1) parser from a functional grammar rule.
+ *
+ * @type {(fr: FRule) => Match}
+ */
+export const parser = fr => {
+    const data = toData(fr)
+    return parserRuleSet(data[0])
+}
+
+/** @type {(tag: AstTag, sequence: AstSequence, r: Remainder) => MatchResult} */
+const mrSuccess = (tag, sequence, r) =>
+    [{tag, sequence}, true, r]
+
+/** @type {(tag: AstTag, sequence: AstSequence, r: Remainder) => MatchResult} */
+const mrFail = (tag, sequence, r) =>
+    [{tag, sequence}, false, r]
+
+/**
+ * Creates an LL(1) parser from an already materialized {@link RuleSet}.
+ *
+ * @type {(ruleSet: RuleSet) => Match}
+ */
+export const parserRuleSet = ruleSet => {
+    const map = dispatchMap(ruleSet)
+
+    /** @type {MatchRule} */
+    const f = ({emptyTag, rangeMap}, cp) => {
+        if (cp.length === 0) {
+            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp)
+        }
+        const [cp0] = cp
+        const dr = dispatchOp.get(rangeMap)(cp0)
+        if (dr === null) {
+            return emptyTag === undefined
+                ? mrFail(emptyTag, [], cp)
+                : mrSuccess(emptyTag, [], cp)
+        }
+        /** @type {AstSequence} */
+        let seq = [cp0]
+        const [, ...restCp] = cp
+        /** @type {readonly number[]} */
+        let r = restCp
+        const {tag, rules} = dr
+        for (const i of rules) {
+            const rule = typeof i === 'string' ? /** @type {_DispatchRule} */ (map[i]) : i
+            const res = f(rule, r)
+            const [astRule, success, newR] = res
+            if (success === false) {
+                return res
+            }
+            seq = [...seq, astRule]
+            if (newR === null) {
+                return mrSuccess(tag, seq, null)
+            }
+            r = newR
+        }
+        return mrSuccess(tag, seq, r)
+    }
+
+    return (name, cp) => f(/** @type {_DispatchRule} */ (map[name]), cp)
+}