functionalscript 0.3.12 → 0.3.14

package/bnf/djs/module.f.d.ts

@@ -2,10 +2,76 @@
  * Rules for serializing and deserializing the BNF grammar.
  *
  * @module
+ *
+ * @example
+ *
+ * ```ts
+ * // Define a simple grammar
+ * const grammar: Rule = () => [
+ *     [range('AZ')],          // 'A-Z'
+ *     [range('az'), grammar], // 'a-z' followed by more grammar
+ * ]
+ *
+ * const parse = parser(toRuleMap(grammar))
+ *
+ * // Parse an input
+ * const input = toArray(stringToCodePointList('abcdefgA'))
+ * const result = parse(grammar.name, input)
+ * if (result === null) { throw result }
+ * const [, b] = result
+ * if (b?.length !== 0) { throw b }
+ * ```
+ */
+import type { CodePoint } from '../../text/utf16/module.f.ts';
+import type { TerminalRange, Rule as FRule } from '../func/module.f.ts';
+/**
+ * Represents a sequence of grammar rules, including terminal ranges or rule identifiers.
+ * @template Id - The type for rule identifiers.
  */
-import type { TerminalRange } from '../module.f.ts';
 export type Sequence<Id> = readonly (TerminalRange | Id)[];
+/**
+ * Represents a grammar rule as a collection of sequences.
+ * @template Id - The type for rule identifiers.
+ */
 export type Rule<Id> = readonly Sequence<Id>[];
+/**
+ * Represents a map of grammar rules, where each rule is identified by a unique string identifier.
+ * @template Id - The type for rule identifiers.
+ */
 export type RuleMap<Id extends string> = {
     readonly [k in Id]: Rule<Id>;
 };
+/**
+ * Transforming functional rule to a serializable rule map.
+ *
+ * @param src a functional rule.
+ * @returns a serializable rule map.
+ */
+export declare const toRuleMap: (src: FRule) => RuleMap<string>;
+/**
+ * Represents a parsed Abstract Syntax Tree (AST) sequence.
+ */
+export type AstSequence = readonly (AstRule | CodePoint)[];
+/**
+ * Represents a parsed AST rule, consisting of a rule name and its parsed sequence.
+ */
+export type AstRule = readonly [string, AstSequence];
+/**
+ * Represents the remaining input after a match attempt, or `null` if no match is possible.
+ */
+export type Remainder = readonly CodePoint[] | null;
+/**
+ * Represents the result of a match operation, including the parsed AST rule and the remainder of the input.
+ */
+export type MatchResult = readonly [AstRule, Remainder];
+/**
+ * Represents an LL(1) parser function for matching input against grammar rules.
+ */
+export type Match = (name: string, s: readonly CodePoint[]) => MatchResult;
+/**
+ * Creates a simple LL1 parser for the given map.
+ *
+ * @param map a prepared rule map.
+ * @returns a parser.
+ */
+export declare const parser: (rm: RuleMap<string>) => Match;

package/bnf/djs/module.f.js

@@ -2,5 +2,206 @@
  * Rules for serializing and deserializing the BNF grammar.
  *
  * @module
+ *
+ * @example
+ *
+ * ```ts
+ * // Define a simple grammar
+ * const grammar: Rule = () => [
+ *     [range('AZ')],          // 'A-Z'
+ *     [range('az'), grammar], // 'a-z' followed by more grammar
+ * ]
+ *
+ * const parse = parser(toRuleMap(grammar))
+ *
+ * // Parse an input
+ * const input = toArray(stringToCodePointList('abcdefgA'))
+ * const result = parse(grammar.name, input)
+ * if (result === null) { throw result }
+ * const [, b] = result
+ * if (b?.length !== 0) { throw b }
+ * ```
+ */
+import { empty as emptyArray } from "../../types/array/module.f.js";
+import { strictEqual } from "../../types/function/operator/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+import { contains } from "../../types/range/module.f.js";
+import { rangeMap } from "../../types/range_map/module.f.js";
+const findName = (map, rule) => {
+    const { name } = rule;
+    let result = name;
+    {
+        let i = 0;
+        while (result in map) {
+            result = name + i;
+            ++i;
+        }
+    }
+    return result;
+};
+/**
+ * Add a new rule to the temporary map.
+ */
+const tmpAdd = ({ queue, result }) => (src) => {
+    // find a name for the item.
+    const name = findName(result, src);
+    return [{
+            // add the item to a queue under the name.
+            queue: [...queue, [src, name]],
+            // add the name to the result and fill the rule later.
+            result: { ...result, [name]: emptyArray },
+        }, name];
+};
+const tmpNew = tmpAdd({
+    queue: emptyArray,
+    result: {},
+});
+const tmpItem = (tmp, src) => {
+    const found = tmp.queue.find(([f]) => f === src);
+    return found !== undefined ? [tmp, found[1]] : tmpAdd(tmp)(src);
+};
+/**
+ * Transforming functional rule to a serializable rule map.
+ *
+ * @param src a functional rule.
+ * @returns a serializable rule map.
+ */
+export const toRuleMap = (src) => {
+    let [tmp] = tmpNew(src);
+    let i = 0;
+    do {
+        const [srcOr, name] = tmp.queue[i];
+        let rule = emptyArray;
+        // iterate all sequences of the `Or` rule.
+        for (const srcSeq of srcOr()) {
+            let s = emptyArray;
+            // iterate all items of the sequence.
+            for (const srcItem of srcSeq) {
+                let item;
+                if (srcItem instanceof Array) {
+                    item = srcItem;
+                }
+                else {
+                    [tmp, item] = tmpItem(tmp, srcItem);
+                }
+                s = [...s, item];
+            }
+            rule = [...rule, s];
+        }
+        // fix the rule in the result.
+        tmp = {
+            queue: tmp.queue,
+            result: { ...tmp.result, [name]: rule },
+        };
+        ++i;
+    } while (i !== tmp.queue.length);
+    return tmp.result;
+};
+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,
+});
+/**
+ * Creates a dispatch map for LL1 parser.
+ *
+ * @param ruleMap a serializable rule map.
+ * @returns A dispatch map
+ */
+const dispatchMap = (ruleMap) => {
+    const dispatchSequence = (dm, sequence) => {
+        let empty = true;
+        let result = [];
+        for (const item of sequence) {
+            if (typeof item === 'string') {
+                dm = dispatchRule(dm, item);
+                const [e, dispatch] = dm[item];
+                result = toArray(dispatchOp.merge(result)(dispatch.map(x => [x[0] === null ? null : sequence, x[1]])));
+                if (e) {
+                    continue;
+                }
+            }
+            else {
+                const dispatch = dispatchOp.fromRange(item)(sequence);
+                result = toArray(dispatchOp.merge(result)(dispatch));
+            }
+            empty = false;
+            break;
+        }
+        return [dm, [empty, result]];
+    };
+    const dispatchRule = (dm, name) => {
+        if (name in dm) {
+            return dm;
+        }
+        let empty = false;
+        let dispatch = [];
+        for (const sequence of ruleMap[name]) {
+            const [newDm, [e, d]] = dispatchSequence(dm, sequence);
+            dm = newDm;
+            empty ||= e;
+            dispatch = toArray(dispatchOp.merge(dispatch)(d));
+        }
+        return { ...dm, [name]: [empty, dispatch] };
+    };
+    let result = {};
+    for (const k in ruleMap) {
+        result = dispatchRule(result, k);
+    }
+    // TODO: validate all sequences if they are deterministic
+    return result;
+};
+/**
+ * Creates a simple LL1 parser for the given map.
+ *
+ * @param map a prepared rule map.
+ * @returns a parser.
  */
-export {};
+export const parser = (rm) => {
+    const map = dispatchMap(rm);
+    const f = (name, s) => {
+        const mr = (a, r) => [[name, a], r];
+        const mre = (a) => mr(a, null);
+        const [empty, sequence] = map[name];
+        if (s.length === 0) {
+            return mr([], empty ? s : null);
+        }
+        const cp = s[0];
+        const i = dispatchOp.get(cp)(sequence);
+        if (i === null) {
+            return mr([], empty ? s : null);
+        }
+        let a = [];
+        let si = s;
+        for (const c of i) {
+            if (typeof c === 'string') {
+                // c is a name
+                const [astRule, newSi] = f(c, si);
+                a = [...a, astRule];
+                if (newSi === null) {
+                    return mre(a);
+                }
+                si = newSi;
+            }
+            else {
+                // c is TerminalRange
+                const [first, ...newSi] = si;
+                if (first === undefined || !contains(c)(first)) {
+                    return mre(a);
+                }
+                a = [...a, first];
+                si = newSi;
+            }
+        }
+        return mr(a, si);
+    };
+    return f;
+};

package/bnf/djs/test.f.d.ts

@@ -1 +1,8 @@
-export {};
+declare const _default: {
+    example: {
+        module: () => void;
+    };
+    classic: () => void;
+    map: () => void;
+};
+export default _default;

package/bnf/djs/test.f.js

@@ -1,8 +1,12 @@
-import { one } from "../../types/range/module.f.js";
-import { toTerminalRangeSequence } from "../module.f.js";
-const s = toTerminalRangeSequence;
-const c = (a) => one(a.codePointAt(0));
-const classic = () => {
+import { cp, range, remove, str } from "../func/module.f.js";
+import { parser, toRuleMap } from "./module.f.js";
+import { classic } from "../func/testlib.f.js";
+import * as j from "../../json/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+const stringify = j.stringify(sort);
+const classicTest = () => {
     const map = {
         json: [
             ['element']
@@ -12,60 +16,58 @@ const classic = () => {
             ['array'],
             ['string'],
             ['number'],
-            s('true'),
-            s('false'),
-            s('null'),
+            str('true'),
+            str('false'),
+            str('null'),
         ],
         object: [
-            [c('{'), 'ws', c('}')],
-            [c('{'), 'members', c('}')],
+            [cp('{'), 'ws', cp('}')],
+            [cp('{'), 'members', cp('}')],
         ],
         members: [
             ['member'],
-            ['member', c(','), 'members'],
+            ['member', cp(','), 'members'],
         ],
         member: [
-            ['ws', 'string', 'ws', c(':'), 'element'],
+            ['ws', 'string', 'ws', cp(':'), 'element'],
         ],
         array: [
-            [c('['), 'ws', c(']')],
-            [c('['), 'elements', c(']')],
+            [cp('['), 'ws', cp(']')],
+            [cp('['), 'elements', cp(']')],
         ],
         elements: [
             ['element'],
-            ['element', c(','), 'elements'],
+            ['element', cp(','), 'elements'],
         ],
         element: [
             ['ws', 'value', 'ws'],
         ],
         string: [
-            [c('"'), 'characters', c('"')],
+            [cp('"'), 'characters', cp('"')],
         ],
         characters: [
             [],
             ['character', 'characters'],
         ],
         character: [
-            [[0x20, 0x21]], // exclude '"' 0x22
-            [[0x23, 0x5B]], // exclude '\' 0x5C
-            [[0x5D, 0x10FFFF]], // 93-1114111
-            [c('\\'), 'escape'], // 92
+            ...remove([0x20, 0x10FFFF], [cp('"'), cp('\\')]),
+            [cp('\\'), 'escape'], // 92
         ],
         escape: [
-            [c('"')],
-            [c('\\')],
-            [c('/')],
-            [c('b')],
-            [c('f')],
-            [c('n')],
-            [c('r')],
-            [c('t')],
-            [c('u'), 'hex', 'hex', 'hex', 'hex'],
+            str('"'),
+            str('\\'),
+            str('/'),
+            str('b'),
+            str('f'),
+            str('n'),
+            str('r'),
+            str('t'),
+            [cp('u'), 'hex', 'hex', 'hex', 'hex'],
         ],
         hex: [
             ['digit'],
-            [[0x41, 0x46]], // A-F
-            [[0x61, 0x66]], // a-f
+            [range('AF')], // A-F
+            [range('af')], // a-f
         ],
         number: [
             ['integer', 'fraction', 'exponent'],
@@ -73,43 +75,44 @@ const classic = () => {
         integer: [
             ['digit'],
             ['onenine', 'digits'],
-            [c('-'), 'digit'],
-            [c('-'), 'onenine', 'digits'],
+            [cp('-'), 'digit'],
+            [cp('-'), 'onenine', 'digits'],
         ],
         digits: [
             ['digit'],
             ['digit', 'digits'],
         ],
         digit: [
-            [c('0')],
+            [cp('0')],
             ['onenine'],
         ],
         onenine: [
-            [[0x31, 0x39]], // 1-9
+            [range('19')],
         ],
         fraction: [
             [],
-            [c('.'), 'digits'],
+            [cp('.'), 'digits'],
         ],
         exponent: [
             [],
-            [c('E'), 'sign', 'digits'],
-            [c('e'), 'sign', 'digits'],
+            [cp('E'), 'sign', 'digits'],
+            [cp('e'), 'sign', 'digits'],
         ],
         sign: [
             [],
-            [c('+')],
-            [c('-')],
+            [cp('+')],
+            [cp('-')],
         ],
         ws: [
             [],
-            [c(' '), 'ws'],
-            [c('\n'), 'ws'],
-            [c('\r'), 'ws'],
-            [c('\t'), 'ws'],
+            [cp(' '), 'ws'],
+            [cp('\n'), 'ws'],
+            [cp('\r'), 'ws'],
+            [cp('\t'), 'ws'],
         ],
     };
-    const _map = map;
+    const result = map;
+    return result;
 };
 const deterministic = () => {
     const map = {
@@ -117,13 +120,13 @@ const deterministic = () => {
             ['ws', 'element']
         ],
         value: [
-            [c('{'), 'ws', 'object', c('}')],
-            [c('['), 'ws', 'array', c(']')],
+            [cp('{'), 'ws', 'object', cp('}')],
+            [cp('['), 'ws', 'array', cp(']')],
             ['string'],
             ['number'],
-            s('true'),
-            s('false'),
-            s('null'),
+            str('true'),
+            str('false'),
+            str('null'),
         ],
         object: [
             [],
@@ -131,10 +134,10 @@ const deterministic = () => {
         ],
         members: [
             [],
-            [c(','), 'ws', 'member', 'members'],
+            [cp(','), 'ws', 'member', 'members'],
         ],
         member: [
-            ['string', 'ws', c(':'), 'ws', 'element'],
+            ['string', 'ws', cp(':'), 'ws', 'element'],
         ],
         array: [
             [],
@@ -142,46 +145,44 @@ const deterministic = () => {
         ],
         elements: [
             [],
-            [c(','), 'ws', 'element', 'elements'],
+            [cp(','), 'ws', 'element', 'elements'],
         ],
         element: [
             ['value', 'ws'],
         ],
         string: [
-            [c('"'), 'characters', c('"')],
+            [cp('"'), 'characters', cp('"')],
         ],
         characters: [
             [],
             ['character', 'characters'],
         ],
         character: [
-            [[0x20, 0x21]], // exclude '"' 0x22
-            [[0x23, 0x5B]], // exclude '\' 0x5C
-            [[0x5D, 0x10FFFF]], // 93-1114111
-            [c('\\'), 'escape'], // 92
+            ...remove([0x20, 0x10FFFF], [cp('"'), cp('\\')]),
+            [cp('\\'), 'escape'], // 92
         ],
         escape: [
-            [c('"')],
-            [c('\\')],
-            [c('/')],
-            [c('b')],
-            [c('f')],
-            [c('n')],
-            [c('r')],
-            [c('t')],
-            [c('u'), 'hex', 'hex', 'hex', 'hex'],
+            [cp('"')],
+            [cp('\\')],
+            [cp('/')],
+            [cp('b')],
+            [cp('f')],
+            [cp('n')],
+            [cp('r')],
+            [cp('t')],
+            [cp('u'), 'hex', 'hex', 'hex', 'hex'],
         ],
         hex: [
             ['digit'],
-            [[0x41, 0x46]], // A-F
-            [[0x61, 0x66]], // a-f
+            [range('AF')],
+            [range('af')],
         ],
         number: [
             ['integer', 'fraction', 'exponent'],
-            [c('-'), 'integer', 'fraction', 'exponent'],
+            [cp('-'), 'integer', 'fraction', 'exponent'],
         ],
         integer: [
-            [c('0')],
+            [cp('0')],
             ['onenine', 'digits'],
         ],
         digits: [
@@ -189,33 +190,93 @@ const deterministic = () => {
             ['digit', 'digits'],
         ],
         digit: [
-            [c('0')],
+            [cp('0')],
             ['onenine'],
         ],
         onenine: [
-            [[0x31, 0x39]], // 1-9
+            [range('19')],
         ],
         fraction: [
             [],
-            [c('.'), 'digit', 'digits'],
+            [cp('.'), 'digit', 'digits'],
         ],
         exponent: [
             [],
-            [c('E'), 'sign', 'digit', 'digits'],
-            [c('e'), 'sign', 'digit', 'digits'],
+            [cp('E'), 'sign', 'digit', 'digits'],
+            [cp('e'), 'sign', 'digit', 'digits'],
         ],
         sign: [
             [],
-            [c('+')],
-            [c('-')],
+            [cp('+')],
+            [cp('-')],
         ],
         ws: [
             [],
-            [c(' '), 'ws'],
-            [c('\n'), 'ws'],
-            [c('\r'), 'ws'],
-            [c('\t'), 'ws'],
+            [cp(' '), 'ws'],
+            [cp('\n'), 'ws'],
+            [cp('\r'), 'ws'],
+            [cp('\t'), 'ws'],
         ],
     };
     const _map = map;
+    return _map;
+};
+export default {
+    example: {
+        module: () => {
+            // Define a simple grammar
+            const grammar = () => [
+                [range('AZ')], // 'A-Z'
+                [range('az'), grammar], // 'a-z' followed by more grammar
+            ];
+            const ruleMap = toRuleMap(grammar);
+            const parse = parser(ruleMap);
+            // Parse an input
+            const input = toArray(stringToCodePointList('abcdefgA'));
+            const result = parse(grammar.name, input);
+            if (result === null) {
+                throw result;
+            }
+            const [, b] = result;
+            if (b?.length !== 0) {
+                throw b;
+            }
+        },
+    },
+    classic: () => {
+        const c = classic();
+        const json = stringify(toRuleMap(c.json));
+        const jsonE = stringify(classicTest());
+        if (json !== jsonE) {
+            //console.error(json)
+            //console.error(jsonE)
+            throw [json, jsonE];
+        }
+    },
+    map: () => {
+        const f = parser(deterministic());
+        // console.error(stringify(x))
+        //
+        const isSuccess = (s) => s?.length === 0;
+        const expect = (s, success) => {
+            const [a, r] = f('json', toArray(stringToCodePointList(s)));
+            if (isSuccess(r) !== success) {
+                throw r;
+            }
+        };
+        //
+        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('   [ 12, false, "a"]  ', true);
+        expect('   [ 12, false2, "a"]  ', false);
+        expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+        expect('   { "q": [ 12, false, [}], "a"] }  ', false);
+    }
 };