functionalscript 0.3.15 → 0.4.1

package/bnf/djs/test.f.js

@@ -1,4 +1,4 @@
-import { cp, range, remove, str } from "../func/module.f.js";
+import { cp, range, remove, set, 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";
@@ -114,14 +114,24 @@ const classicTest = () => {
     const result = map;
     return result;
 };
+const repeat0Name = (v) => `${v}Repeat0`;
+const repeat0Body = (v) => [
+    [],
+    [v, repeat0Name(v)]
+];
+const repeat0 = (v) => {
+    const name = repeat0Name(v);
+    const body = repeat0Body(v);
+    return { [name]: body };
+};
 const deterministic = () => {
     const map = {
         json: [
-            ['ws', 'element']
+            ['wsRepeat0', 'element']
         ],
         value: [
-            [cp('{'), 'ws', 'object', cp('}')],
-            [cp('['), 'ws', 'array', cp(']')],
+            [cp('{'), 'wsRepeat0', 'object', cp('}')],
+            [cp('['), 'wsRepeat0', 'array', cp(']')],
             ['string'],
             ['number'],
             str('true'),
@@ -130,14 +140,14 @@ const deterministic = () => {
         ],
         object: [
             [],
-            ['member', 'members'],
+            ['member', 'memberTailRepeat0'],
         ],
-        members: [
-            [],
-            [cp(','), 'ws', 'member', 'members'],
+        memberTail: [
+            [cp(','), 'wsRepeat0', 'member']
         ],
+        ...repeat0('memberTail'),
         member: [
-            ['string', 'ws', cp(':'), 'ws', 'element'],
+            ['string', 'wsRepeat0', cp(':'), 'wsRepeat0', 'element'],
         ],
         array: [
             [],
@@ -145,31 +155,21 @@ const deterministic = () => {
         ],
         elements: [
             [],
-            [cp(','), 'ws', 'element', 'elements'],
+            [cp(','), 'wsRepeat0', 'element', 'elements'],
         ],
         element: [
-            ['value', 'ws'],
+            ['value', 'wsRepeat0'],
         ],
         string: [
-            [cp('"'), 'characters', cp('"')],
-        ],
-        characters: [
-            [],
-            ['character', 'characters'],
+            [cp('"'), 'characterRepeat0', cp('"')],
         ],
+        ...repeat0('character'),
         character: [
             ...remove([0x20, 0x10FFFF], [cp('"'), cp('\\')]),
             [cp('\\'), 'escape'], // 92
         ],
         escape: [
-            [cp('"')],
-            [cp('\\')],
-            [cp('/')],
-            [cp('b')],
-            [cp('f')],
-            [cp('n')],
-            [cp('r')],
-            [cp('t')],
+            ...set('"\\/bfnrt'),
             [cp('u'), 'hex', 'hex', 'hex', 'hex'],
         ],
         hex: [
@@ -177,18 +177,18 @@ const deterministic = () => {
             [range('AF')],
             [range('af')],
         ],
+        numberSign: [
+            [],
+            [cp('-')]
+        ],
         number: [
-            ['integer', 'fraction', 'exponent'],
-            [cp('-'), 'integer', 'fraction', 'exponent'],
+            ['numberSign', 'integer', 'fraction', 'exponent'],
         ],
         integer: [
             [cp('0')],
-            ['onenine', 'digits'],
-        ],
-        digits: [
-            [],
-            ['digit', 'digits'],
+            ['onenine', 'digitRepeat0'],
         ],
+        ...repeat0('digit'),
         digit: [
             [cp('0')],
             ['onenine'],
@@ -198,25 +198,20 @@ const deterministic = () => {
         ],
         fraction: [
             [],
-            [cp('.'), 'digit', 'digits'],
+            [cp('.'), 'digit', 'digitRepeat0'],
         ],
+        e: set('Ee'),
         exponent: [
             [],
-            [cp('E'), 'sign', 'digit', 'digits'],
-            [cp('e'), 'sign', 'digit', 'digits'],
+            ['e', 'sign', 'digit', 'digitRepeat0'],
         ],
         sign: [
             [],
             [cp('+')],
             [cp('-')],
         ],
-        ws: [
-            [],
-            [cp(' '), 'ws'],
-            [cp('\n'), 'ws'],
-            [cp('\r'), 'ws'],
-            [cp('\t'), 'ws'],
-        ],
+        ws: set(' \n\r\t'),
+        ...repeat0('ws'),
     };
     const _map = map;
     return _map;

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

@@ -1,15 +1,13 @@
 /**
- *  Types for defining language grammar using Backus-Naur Form (BNF).
- *
- * @module
- *
- * @description
+ * Types for defining language grammar using Backus-Naur Form (BNF).
  *
  * Utilities for serializing and deserializing BNF grammar
  * and creating a simple LL(1) parser.
  *
  * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
  *
+ * @module
+ *
  * @example
  *
  * ```ts
@@ -124,6 +122,13 @@ type RangeSet = readonly TerminalRange[];
  * A set of terminal ranges compatible with the `Or` rule.
  */
 export type OrRangeSet = readonly (readonly [TerminalRange])[];
+/**
+ * Convert a sequence of character into `OrRangeSet`
+ *
+ * @param s a set of code points
+ * @returns A set compatible with `Or`
+ */
+export declare const set: (s: string) => OrRangeSet;
 /**
  * Removes a terminal range from a set of ranges.
  *
@@ -138,4 +143,6 @@ export type OrRangeSet = readonly (readonly [TerminalRange])[];
  * ```
  */
 export declare const remove: (range: TerminalRange, removeSet: RangeSet) => OrRangeSet;
+export declare const repeat0: (rule: Rule) => Rule;
+export declare const join0: (rule: Rule, separator: Rule) => Rule;
 export {};

package/bnf/func/module.f.js

@@ -1,15 +1,13 @@
 /**
- *  Types for defining language grammar using Backus-Naur Form (BNF).
- *
- * @module
- *
- * @description
+ * Types for defining language grammar using Backus-Naur Form (BNF).
  *
  * Utilities for serializing and deserializing BNF grammar
  * and creating a simple LL(1) parser.
  *
  * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
  *
+ * @module
+ *
  * @example
  *
  * ```ts
@@ -73,6 +71,14 @@ export const range = (ab) => {
     // deno-lint-ignore no-explicit-any
     return a;
 };
+const toOr = (r) => r.map(v => [v]);
+/**
+ * Convert a sequence of character into `OrRangeSet`
+ *
+ * @param s a set of code points
+ * @returns A set compatible with `Or`
+ */
+export const set = (s) => toOr(str(s));
 const removeOne = (set, [a, b]) => {
     let result = [];
     for (const [a0, b0] of set) {
@@ -107,5 +113,20 @@ export const remove = (range, removeSet) => {
     for (const r of removeSet) {
         result = removeOne(result, r);
     }
-    return result.map(v => [v]);
+    return toOr(result);
+};
+export const repeat0 = (rule) => {
+    const result = () => [
+        [],
+        [rule, result],
+    ];
+    return result;
+};
+export const join0 = (rule, separator) => {
+    const tail = repeat0(() => [[separator, rule]]);
+    const result = () => [
+        [],
+        [rule, tail],
+    ];
+    return result;
 };

package/bnf/func/test.f.js

@@ -1,20 +1,14 @@
 import { stringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-import { cp, str, range, remove, } from "./module.f.js";
+import { cp, str, range, remove, set, repeat0, join0, } from "./module.f.js";
 const deterministic = () => {
+    const wsSet = () => set('\t\n\r '); // 9,10,13,32
     // {"empty":true,"map":[[false,8],[true,10],[false,12],[true,13],[false,31],[true,32]]}
-    const ws = () => [
-        [],
-        [cp('\t'), ws], // 9
-        [cp('\n'), ws], // 10
-        [cp('\r'), ws], // 13
-        [cp(' '), ws], // 32
-    ];
+    const ws = repeat0(wsSet);
     // {"empty":true,"map":[[false,42],[true,43],[false,44],[true,45]]}
     const sign = () => [
         [],
-        str('+'), // 43
-        str('-'), // 45
+        ...set('+-'), // 43
     ];
     // {"empty":false,"map":[[false,48],[true,57]]}
     const onenine = () => [
@@ -26,34 +20,31 @@ const deterministic = () => {
         [onenine],
     ];
     // {"empty":true,"map":[[false,47],[true,57]]}
-    const digits1 = () => [
-        [],
-        [digit, digits1]
-    ];
+    const digits0 = repeat0(digit);
     // {"empty":false,"map":[[false,47],[true,57]]}
-    const digits = () => [
-        [digit, digits1]
+    const digits1 = () => [
+        [digit, digits0]
     ];
+    const e = () => set('Ee'); // 69, 101
     // {"empty":true,"map":[[false,68],[true,69],[false,100],[true,101]]}
     const exponent = () => [
         [],
-        [cp('E'), sign, digits], // 69
-        [cp('e'), sign, digits], // 101
+        [e, sign, digits1], // 69 | 101
     ];
     // {"empty":true,"map":[[false,45],[true,46]]}
     const fraction = () => [
         [],
-        [cp('.'), digits] // 46
+        [cp('.'), digits1] // 46
     ];
     // {"empty":false,"map":[[false,47],[true,57]]}
-    const integer1 = () => [
+    const unsignedInteger = () => [
         str('0'), // 48
-        [onenine, digits1], // 49-57
+        [onenine, digits0], // 49-57
     ];
     // {"empty":false,"map":[[false,44],[true,45],[false,47],[true,57]]}
     const integer = () => [
-        [integer1], // 48-57
-        [cp('-'), integer1], // 45
+        [unsignedInteger], // 48-57
+        [cp('-'), unsignedInteger], // 45
     ];
     // {"empty":false,"map":[[false,44],[true,45],[false,47],[true,57]]}
     const number = () => [
@@ -67,14 +58,7 @@ const deterministic = () => {
     ];
     // {"empty":false,"map":[[false,33],[true,34],[false,46],[true,47],[false,91],[true,92],[false,97],[true,98],[false,101],[true,102],[false,109],[true,110],[false,113],[true,114],[false,115],[true,117]]}
     const escape = () => [
-        str('"'), //  34
-        str('/'), //  47
-        str('\\'), //  92
-        str('b'), //  98
-        str('f'), // 102
-        str('n'), // 110
-        str('r'), // 114
-        str('t'), // 116
+        ...set('"\\/bfnrt'),
         [cp('u'), hex, hex, hex, hex] // 117
     ];
     // {"empty":false,"map":[[false,31],[true,33],[false,34],[true,1114111]]}
@@ -83,70 +67,27 @@ const deterministic = () => {
         [cp('\\'), escape], // 92
     ];
     // {"empty":true,"map":[[false,31],[true,33],[false,34],[true,1114111]]}
-    const characters = () => [
-        [],
-        [character, characters]
-    ];
+    const characters = repeat0(character);
     // {"empty":false,"map":[[false,33],[true,34]]}
     const string = () => [
         [cp('"'), characters, cp('"')]
     ];
+    const comma = () => [[cp(','), ws]];
     // {"empty":false,"map":[[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
-    const element1 = () => [
-        [value, ws]
-    ];
-    // {"empty":false,"map":[[false,8],[true,10],[false,12],[true,13],[false,31],[true,32],[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
     const element = () => [
-        [ws, element1]
-    ];
-    // {"empty":true,"map":[[false,43],[true,44]]}
-    const elements2 = () => [
-        [],
-        [cp(','), elements] // 44
-    ];
-    // {"empty":false,"map":[[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
-    const elements1 = () => [
-        [element1, elements2]
-    ];
-    // {"empty":false,"map":[[false,8],[true,10],[false,12],[true,13],[false,31],[true,32],[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
-    const elements = () => [
-        [ws, elements1]
+        [value, ws]
     ];
-    // {"empty":false,"map":[[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,92],[true,93],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
-    const array1 = () => [
-        str(']'), // 93
-        [elements1, cp(']')],
+    const list = (open, rule, close) => () => [
+        [cp(open), ws, join0(rule, comma), cp(close)]
     ];
     // {"empty":false,"map":[[false,90],[true,91]]}
-    const array = () => [
-        [cp('['), ws, array1]
-    ];
+    const array = list('[', element, ']');
     // {"empty":false,"map":[[false,33],[true,34]]}
-    const member1 = () => [
-        [string, ws, cp(':'), element]
-    ];
-    // {"empty":true,"map":[[false,43],[true,44]]}
-    const members2 = () => [
-        [],
-        [cp(','), members], // 44
-    ];
-    // {"empty":false,"map":[[false,33],[true,34]]}
-    const members1 = () => [
-        [member1, members2]
-    ];
-    // {"empty":false,"map":[[false,8],[true,10],[false,12],[true,13],[false,31],[true,32],[false,33],[true,34]]}
-    const members = () => [
-        [ws, members1]
-    ];
-    // {"empty":false,"map":[[false,33],[true,34],[false,124],[true,125]]}
-    const object1 = () => [
-        str('}'), // 125
-        [members1, cp('}')],
+    const member = () => [
+        [string, ws, cp(':'), ws, element]
     ];
     // {"empty":false,"map":[[false,122],[true,123]]}
-    const object = () => [
-        [cp('{'), ws, object1]
-    ];
+    const object = list('{', member, '}');
     // {"empty":false,"map":[[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
     const value = () => [
         [object], // 123
@@ -158,7 +99,7 @@ const deterministic = () => {
         str('null'), // 110
     ];
     // {"empty":false,"map":[[false,8],[true,10],[false,12],[true,13],[false,31],[true,32],[false,33],[true,34],[false,44],[true,45],[false,47],[true,57],[false,90],[true,91],[false,101],[true,102],[false,109],[true,110],[false,115],[true,116],[false,122],[true,123]]}
-    const json = element;
+    const json = [ws, element];
     const _ = json;
 };
 //

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

@@ -0,0 +1,30 @@
+import { type Array2 } from '../../types/array/module.f.ts';
+export type Range = bigint;
+export type Sequence = readonly Rule[];
+export type Or = {
+    readonly [k in string]: Rule;
+};
+export type DataRule = Or | Sequence | Range | string;
+export type LazyRule = () => DataRule;
+export type Rule = DataRule | LazyRule;
+export declare const rangeEncode: (a: number, b: number) => Range;
+export declare const oneEncode: (a: number) => Range;
+export declare const rangeDecode: (r: bigint) => Array2<number>;
+export declare const str: (s: string) => readonly Range[] | Range;
+export declare const set: (s: string) => Or;
+export declare const range: (ab: string) => Range;
+export type None = readonly [];
+export declare const none: None;
+export type Option<S> = {
+    none: None;
+    some: S;
+};
+export declare const option: <S extends Rule>(some: S) => Option<S>;
+export type Repeat0<T> = () => Option<readonly [T, Repeat0<T>]>;
+export declare const repeat0: <T extends Rule>(some: T) => Repeat0<T>;
+export type Repeat1<T> = readonly [T, Repeat0<T>];
+export declare const repeat1: <T extends Rule>(some: T) => Repeat1<T>;
+export type Join1<T, S> = readonly [T, Repeat0<readonly [S, T]>];
+export declare const join1: <T extends Rule, S extends Rule>(some: T, separator: S) => Join1<T, S>;
+export type Join0<T, S> = Option<readonly [T, Repeat0<readonly [S, T]>]>;
+export declare const join0: <T extends Rule, S extends Rule>(some: T, separator: S) => Rule;

package/bnf/tag/module.f.js

@@ -0,0 +1,37 @@
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { isArray2 } from "../../types/array/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+//
+const { fromEntries } = Object;
+const { fromCodePoint } = String;
+const offset = 24n;
+const mask = (1n << offset) - 1n;
+export const rangeEncode = (a, b) => (BigInt(a) << offset) | BigInt(b);
+export const oneEncode = (a) => rangeEncode(a, a);
+export const rangeDecode = (r) => [Number(r >> offset), Number(r & mask)];
+const mapOneEncode = map(oneEncode);
+export const str = (s) => {
+    const x = toArray(mapOneEncode(stringToCodePointList(s)));
+    return x.length === 1 ? x[0] : x;
+};
+const mapEntry = map((v) => [fromCodePoint(v), oneEncode(v)]);
+export const set = (s) => fromEntries(toArray(mapEntry(stringToCodePointList(s))));
+export const range = (ab) => {
+    const a = toArray(stringToCodePointList(ab));
+    if (!isArray2(a)) {
+        throw `Invalid range ${ab}.`;
+    }
+    return rangeEncode(...a);
+};
+export const none = [];
+export const option = (some) => ({
+    none,
+    some,
+});
+export const repeat0 = (some) => {
+    const f = () => option([some, f]);
+    return f;
+};
+export const repeat1 = (some) => [some, repeat0(some)];
+export const join1 = (some, separator) => [some, repeat0([separator, some])];
+export const join0 = (some, separator) => option(join1(some, separator));

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

@@ -0,0 +1 @@
+export {};

package/bnf/tag/test.f.js

@@ -0,0 +1,138 @@
+import { join0, none, option, range, repeat0, set } from "./module.f.js";
+const _classic = () => {
+    const json = () => [element];
+    const value = () => ({
+        object,
+        array,
+        string,
+        number,
+        true: 'true',
+        false: 'false',
+        null: 'null'
+    });
+    const object = () => ({
+        ws: ['{', ws, '}'],
+        members: ['{', members, '}'],
+    });
+    const members = () => ({
+        member,
+        members: [member, ',', members],
+    });
+    const member = () => [ws, string, ws, ':', element];
+    const array = () => ({
+        ws: ['[', ws, ']'],
+        elements: ['[', elements, ']'],
+    });
+    const elements = () => ({
+        element,
+        elements: [element, ',', elements],
+    });
+    const element = () => [ws, value, ws];
+    const string = () => ['"', characters, '"'];
+    const characters = () => ({
+        none,
+        characters: [character, characters],
+    });
+    const character = () => ({
+        0: 0x20000021n,
+        1: 0x2300005bn,
+        2: 0x5d10ffffn,
+        escape: ['\\', escape],
+    });
+    const escape = () => ({
+        ...set('"\\/bfnrt'),
+        u: ['u', hex, hex, hex, hex],
+    });
+    const hex = () => ({
+        digit,
+        AF: range('AF'),
+        af: range('af'),
+    });
+    const number = () => [integer, fraction, exponent];
+    const integer = () => ({
+        digit,
+        onenine: [onenine, digits],
+        negDigit: ['-', digit],
+        negOnenine: ['-', onenine, digits],
+    });
+    const digits = () => ({
+        digit,
+        digits: [digit, digits],
+    });
+    const digit = () => ({
+        '0': '0',
+        onenine,
+    });
+    const onenine = range('12');
+    const fraction = () => ({
+        none,
+        digits: ['.', digits],
+    });
+    const exponent = () => ({
+        none,
+        E: ['E', sign, digits],
+        e: ['e', sign, digits],
+    });
+    const sign = {
+        none,
+        ...set('+-'),
+    };
+    const ws = () => ({
+        none,
+        ' ': [' ', ws],
+        '\n': ['\n', ws],
+        '\r': ['\r', ws],
+        '\t': ['\t', ws],
+    });
+    return json;
+};
+const _deterministic = () => {
+    const onenine = range('12');
+    const digit = {
+        '0': '0',
+        onenine,
+    };
+    const hex = {
+        digit,
+        AF: range('AF'),
+        af: range('af'),
+    };
+    const escape = {
+        ...set('"\\/bfnrt'),
+        u: ['u', hex, hex, hex, hex],
+    };
+    const character = {
+        0: 0x20000021n,
+        1: 0x2300005bn,
+        2: 0x5d10ffffn,
+        escape: ['\\', escape],
+    };
+    const characters = repeat0(character);
+    const string = ['"', characters, '"'];
+    const digits0 = repeat0(digit);
+    const digits = [digit, digits0];
+    const integer = [option('-'), {
+            '0': '0',
+            onenine: [onenine, digits0],
+        }];
+    const fraction = option(['.', digits]);
+    const sign = option(set('+-'));
+    const exponent = option([set('Ee'), sign, digits]);
+    const number = [integer, fraction, exponent];
+    const ws = repeat0(set(' \n\r\t'));
+    const value = () => ({
+        object,
+        array,
+        string,
+        number,
+        true: 'true',
+        false: 'false',
+        null: 'null'
+    });
+    const commaJoin0 = ([open, close], a) => [open, ws, join0([a, ws], [',', ws]), close];
+    const array = commaJoin0('[]', value);
+    const member = [string, ws, ':', ws, value];
+    const object = commaJoin0('{}', member);
+    const json = [ws, value, ws];
+    return json;
+};

package/fsc/bnf.f.d.ts

@@ -0,0 +1,2 @@
+import { type Rule } from '../bnf/func/module.f.ts';
+export declare const wsModule: Rule;

package/fsc/bnf.f.js

@@ -0,0 +1,54 @@
+import { cp, range, remove, set, str } from "../bnf/func/module.f.js";
+import { digit, json, unicode, ws0, ws1, wsNoNewLine0 } from "./json.f.js";
+export const wsModule = () => [[ws0, module]];
+const module = () => [
+    [json, ws0],
+    [fjs],
+];
+const fjs = () => [
+    [],
+    [...str('const'), ws1, id, ws0, cp('='), ws0, json, wsNoNewLine0, fjsTail],
+    [...str('export'), ws1, ...str('default'), ws1, json],
+];
+const fjsTail = () => [
+    [],
+    [cp('\n'), ws0, fjs],
+];
+// line comment
+const lineItem = () => remove(unicode, [cp('\n')]);
+const line = () => [
+    [],
+    [lineItem, line]
+];
+const lineComment = () => [
+    [cp('/'), commentTail, cp('\n')]
+];
+const multiLineSkip = () => remove(unicode, [cp('/')]);
+const multiLineItem = () => remove(unicode, [cp('*')]);
+const multiLine = () => [
+    [cp('*'), multiLineTail],
+    [multiLineItem, multiLine]
+];
+const multiLineTail = () => [
+    [cp('/')],
+    [multiLineSkip, multiLine]
+];
+const commentTail = () => [
+    [cp('/'), lineComment],
+    [cp('*'), multiLine],
+];
+// id
+const id = () => [[alpha, idTail0]];
+const alpha = () => [
+    [range('AZ')],
+    [range('az')],
+    ...set('_$'),
+];
+const idTail0 = () => [
+    [],
+    [alphaDigit, idTail0],
+];
+const alphaDigit = () => [
+    [alpha],
+    [digit],
+];