functionalscript 0.32.4 → 0.34.0

package/README.md

@@ -11,7 +11,7 @@ FunctionalScript is a safe, purely functional programming language and a strict
   as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
-[A working draft of the FunctionalScript specification](./issues/lang/README.md).
+[A working draft of the FunctionalScript specification](./todo/lang/README.md).
 
 Learn more about
 

package/fs/asserts/module.f.d.ts

@@ -1,4 +1,4 @@
 export declare const todo: () => never;
 export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-export declare const assertEq: <T>(a: T, b: T) => void;
+export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
 export type Assert<T extends true> = T;

package/fs/asserts/module.f.js

@@ -3,4 +3,7 @@ export const assert = (v, msg = 'assertion failed') => {
     if (!v)
         throw msg;
 };
-export const assertEq = (a, b) => assert(a === b, [a, b]);
+export const assertEq = (...x) => {
+    const [a, b] = x;
+    assert(a === b, x);
+};

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

@@ -1,11 +1,3 @@
-/**
- * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
- * for FunctionalScript BNF rules.
- *
- * @module
- */
-import { type CodePoint } from '../../text/utf16/module.f.ts';
-import { type RangeMapArray } from '../../types/range_map/module.f.ts';
 import { type Rule as FRule } from '../module.f.ts';
 import { type StringMap } from '../../types/object/module.f.ts';
 /**
@@ -31,103 +23,8 @@ export type Variant = StringMap<string, string>;
 export type Rule = Variant | Sequence | TerminalRange;
 /** The full grammar */
 export type RuleSet = Readonly<Record<string, Rule>>;
-type EmptyTag = string | true | undefined;
-type EmptyTagEntry = string | boolean;
-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>;
-type EmptyTagMap = StringMap<string, EmptyTagEntry>;
-/**
- * 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>;
-};
-/**
- * Represents a parsed Abstract Syntax Tree (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;
 /**
  * Converts a functional grammar rule into serializable BNF data and returns
  * the generated rule set with the entry rule identifier.
  */
 export declare const toData: (fr: FRule) => readonly [RuleSet, string];
-/**
- * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
- */
-export declare const dispatchMap: (ruleSet: RuleSet) => DispatchMap;
-/**
- * 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>;
-/**
- * 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 {};

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

@@ -1,17 +1,19 @@
 /**
- * Provides grammar-to-data conversion and LL(1) dispatch/matching types and helpers
- * for FunctionalScript BNF rules.
+ * The serializable BNF intermediate representation (IR) and the
+ * {@link toData} conversion from the functional grammar.
+ *
+ * This module is the pure, parser-agnostic substrate: it defines the
+ * {@link RuleSet} data form (`Rule = Variant | Sequence | TerminalRange`) and
+ * converts a functional grammar into it. The automaton builders that consume a
+ * {@link RuleSet} live in their own sibling modules (`fs/bnf/ll1`,
+ * `fs/bnf/descent`, …), so the IR stays free of any one parser's machinery.
  *
  * @module
  */
 import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { strictEqual } from "../../types/function/operator/module.f.js";
 import { map, toArray } from "../../types/list/module.f.js";
-import { rangeMap } from "../../types/range_map/module.f.js";
-import { contains, set } from "../../types/string_set/module.f.js";
-import { contains as rangeContains } from "../../types/range/module.f.js";
-import { oneEncode, rangeDecode, } from "../module.f.js";
-import { definedEntries } from "../../types/object/module.f.js";
+import { oneEncode, } from "../module.f.js";
+import {} from "../../types/object/module.f.js";
 const { entries } = Object;
 const find = (map) => (fr) => {
     for (const [k, v] of entries(map)) {
@@ -89,241 +91,3 @@ export const toData = (fr) => {
     const [, ruleSet, id] = toDataAdd({})(fr);
     return [ruleSet, id];
 };
-const dispatchOp = rangeMap({
-    union: a => b => {
-        if (a === null) {
-            return b;
-        }
-        if (b === null) {
-            return a;
-        }
-        throw ['can not merge [', a, '][', b, ']'];
-    },
-    equal: strictEqual,
-    def: null,
-});
-/**
- * Builds a dispatch map for a {@link RuleSet} to enable predictive parsing.
- */
-export const dispatchMap = (ruleSet) => {
-    const addRuleToDispatch = (dr, name) => {
-        if (dr === null)
-            return null;
-        return { tag: dr.tag, rules: [...dr.rules, name] };
-    };
-    const addTagToDispatch = (dr, tag) => {
-        if (dr === null)
-            return null;
-        return { tag, rules: dr.rules };
-    };
-    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(range)({ tag: undefined, rules: [] });
-            const dr = { emptyTag: undefined, rangeMap: dispatch };
-            return { ...dm, [name]: dr };
-        }
-        else if (rule instanceof Array) {
-            let emptyTag = true;
-            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 = dm[item];
-                    if (emptyTag === true) {
-                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
-                        result = toArray(dispatchOp.merge(result)(dr.rangeMap));
-                        emptyTag = dr.emptyTag !== undefined ? true : undefined;
-                    }
-                    else {
-                        result = result.map(x => [addRuleToDispatch(x[0], item), x[1]]);
-                    }
-                }
-            }
-            const dr = { emptyTag, rangeMap: result };
-            return { ...dm, [name]: dr };
-        }
-        else {
-            const entries = definedEntries(rule);
-            let result = [];
-            let emptyTag = undefined;
-            for (const [tag, item] of entries) {
-                dm = dispatchRule(dm, item, newCurrent);
-                const dr = dm[item];
-                if (dr.emptyTag !== undefined) {
-                    emptyTag = tag;
-                }
-                else {
-                    const d = dr.rangeMap.map(x => [addTagToDispatch(x[0], tag), x[1]]);
-                    result = toArray(dispatchOp.merge(result)(d));
-                }
-            }
-            const dr = { emptyTag, rangeMap: result };
-            return { ...dm, [name]: dr };
-        }
-    };
-    let result = {};
-    for (const k in ruleSet) {
-        result = dispatchRule(result, k, null);
-    }
-    return result;
-};
-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;
-};
-/**
- * Creates an LL(1) parser from a functional grammar rule.
- */
-export const parser = (fr) => {
-    const data = toData(fr);
-    return parserRuleSet(data[0]);
-};
-/**
- * Creates an LL(1) parser from an already materialized {@link RuleSet}.
- */
-export const parserRuleSet = (ruleSet) => {
-    const map = dispatchMap(ruleSet);
-    const f = (rule, cp) => {
-        const mrSuccess = (tag, sequence, r) => [{ tag, sequence }, true, r];
-        const mrFail = (tag, sequence, r) => [{ tag, sequence }, false, r];
-        const { emptyTag, rangeMap } = rule;
-        if (cp.length === 0) {
-            return mrSuccess(emptyTag, [], emptyTag === undefined ? null : cp);
-        }
-        const cp0 = cp[0];
-        const dr = dispatchOp.get(cp0)(rangeMap);
-        if (dr === null) {
-            if (emptyTag === undefined) {
-                return mrFail(emptyTag, [], cp);
-            }
-            return mrSuccess(emptyTag, [], cp);
-        }
-        let seq = [cp0];
-        let r = cp;
-        const [_, ...restCp] = cp;
-        r = restCp;
-        const { tag, rules } = dr;
-        for (const i of rules) {
-            const rule = typeof i === 'string' ? 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(map[name], cp);
-};

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

@@ -2,13 +2,6 @@ export declare const proof: {
     rangeDecode: () => void;
     rangeEncode: () => void;
     toData: (() => void)[];
-    emptyTags: (() => void)[];
     variantTest: () => void;
-    dispatch: (() => void)[];
-    parser: (() => void)[];
-    descentParser: (() => void)[];
-    descentParserWithMeta: (() => void)[];
-    repeat: (() => void)[];
-    repeatParser: (() => void)[];
     example: () => void;
 };