functionalscript 0.4.0 → 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],
+];

package/fsc/json.f.d.ts

@@ -0,0 +1,7 @@
+import { type Rule, type TerminalRange } from '../bnf/func/module.f.ts';
+export declare const wsNoNewLine0: Rule;
+export declare const ws0: Rule;
+export declare const ws1: Rule;
+export declare const json: Rule;
+export declare const unicode: TerminalRange;
+export declare const digit: Rule;

package/fsc/json.f.js

@@ -0,0 +1,89 @@
+import { cp, join0, range, remove, repeat0, set, str } from "../bnf/func/module.f.js";
+// space
+const wsNoNewLineItem = () => set(' \t\r');
+export const wsNoNewLine0 = () => [
+    [],
+    [wsNoNewLineItem, wsNoNewLine0],
+];
+const wsItem = () => [
+    [wsNoNewLineItem],
+    str('\n'),
+];
+export const ws0 = () => [
+    [],
+    [ws1],
+];
+export const ws1 = () => [
+    [wsItem, ws0]
+];
+//
+export const json = () => [
+    [object],
+    [array],
+    [number],
+    [string],
+    str('true'),
+    str('false'),
+    str('null'),
+];
+//
+const separator = () => [[cp(','), ws0]];
+// object
+const member = () => [[string, ws0, cp(':'), ws0, json, ws0]];
+const object = () => [
+    [cp('{'), ws0, join0(member, separator), cp('}')]
+];
+// array
+const element = () => [
+    [json, ws0]
+];
+const array = () => [
+    [cp('['), ws0, join0(element, separator), cp(']')]
+];
+// string
+const character = () => [
+    ...remove(unicode, [cp('"'), cp('\\')]),
+    [cp('\\'), escape],
+];
+const string = () => [[cp('"'), repeat0(character), cp('"')]];
+export const unicode = [0x20, 0x10FFFF];
+const escape = () => [
+    ...set('"\\/bfnrt'),
+    [cp('u'), hex, hex, hex, hex] // 117
+];
+const hex = () => [
+    [digit],
+    [range('AF')],
+    [range('af')],
+];
+// number
+const number = () => [
+    [uNumber],
+    [cp('-'), uNumber],
+];
+const uNumber = () => [
+    [uint, fraction0, exponent0],
+];
+const uint = () => [
+    str('0'),
+    [range('19'), digits0]
+];
+export const digit = () => [[range('09')]];
+const digits0 = repeat0(digit);
+const digits1 = () => [
+    [digit, digits0]
+];
+const fraction0 = () => [
+    [],
+    [cp('.'), digits1]
+];
+const exponent0 = () => [
+    [],
+    [e, sign, digits1],
+];
+const e = () => set('eE');
+const sign = () => [
+    [],
+    [cp('+')],
+    [cp('-')],
+];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.4.0",
+  "version": "0.4.1",
   "type": "module",
   "files": [
     "**/*.f.d.ts",

package/types/array/module.f.d.ts

@@ -6,6 +6,7 @@
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
+export declare const isArray2: <T>(a: readonly T[]) => a is Array2<T>;
 export type Tuple2<T0, T1> = readonly [T0, T1];
 export type Index2 = 0 | 1;
 export type Array3<T> = readonly [T, T, T];

package/types/array/module.f.js

@@ -4,6 +4,7 @@
  * @module
  */
 import { map } from "../nullable/module.f.js";
+export const isArray2 = (a) => a.length === 2;
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);
 export const at = (i) => (a) => {

package/types/bigint/module.f.d.ts

@@ -13,6 +13,7 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
+ * const m = min(3n)(13n) // 3n
  * ```
  */
 import { type Sign } from '../function/compare/module.f.ts';
@@ -42,6 +43,7 @@ export declare const serialize: (a: bigint) => string;
  *    of the most significant bit.
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
+ * 3. **Remainder Phase:** Using `Math.log2`.
  */
 export declare const log2: (v: bigint) => bigint;
 /**
@@ -78,3 +80,7 @@ export declare const bitLength: (v: bigint) => bigint;
  * ```
  */
 export declare const mask: (len: bigint) => bigint;
+/**
+ * A minimal value.
+ */
+export declare const min: (a: bigint) => (b: bigint) => bigint;

package/types/bigint/module.f.js

@@ -13,6 +13,7 @@
  * const logValue = log2(8n) // 3n
  * const bitCount = bitLength(255n) // 8n
  * const bitmask = mask(5n) // 31n
+ * const m = min(3n)(13n) // 3n
  * ```
  */
 import { unsafeCmp } from "../function/compare/module.f.js";
@@ -39,13 +40,19 @@ export const serialize = (a) => `${a}n`;
  *    of the most significant bit.
  * 2. **Binary Search Phase:** Refines the result by halving the step size and incrementally
  *    determining the exact value of the logarithm.
+ * 3. **Remainder Phase:** Using `Math.log2`.
  */
 export const log2 = (v) => {
     if (v <= 0n) {
         return -1n;
     }
-    let result = 31n;
-    let i = 32n;
+    //
+    // 1. Fast Doubling.
+    //
+    let result = -1n;
+    // `bigints` higher than 2**1023 may lead to `Inf` during conversion to `number`.
+    // For example: `Number((1n << 1024n) - (1n << 970n)) === Inf`.
+    let i = 1023n;
     while (true) {
         const n = v >> i;
         if (n === 0n) {
@@ -56,9 +63,12 @@ export const log2 = (v) => {
         result += i;
         i <<= 1n;
     }
+    //
+    // 2. Binary Search.
+    //
     // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
-    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
-    while (i !== 32n) {
+    // Because of this, We check if `i` is greater than 1023 before we divide it by 2.
+    while (i !== 1023n) {
         i >>= 1n;
         const n = v >> i;
         if (n !== 0n) {
@@ -66,7 +76,15 @@ export const log2 = (v) => {
             v = n;
         }
     }
-    return result - BigInt(Math.clz32(Number(v)));
+    //
+    // 3. Remainder Phase.
+    //
+    // We know that `v` is less than `1n << 1023` so we can calculate a remainder using
+    // `Math.log2`.
+    const rem = BigInt(Math.log2(Number(v)) | 0);
+    // (v >> rem) is either `0` or `1`, and it's used as a correction for
+    // Math.log2 rounding.
+    return result + rem + (v >> rem);
 };
 /**
  * Calculates the bit length of a given BigInt.
@@ -110,3 +128,7 @@ export const bitLength = (v) => {
  * ```
  */
 export const mask = (len) => (1n << len) - 1n;
+/**
+ * A minimal value.
+ */
+export const min = (a) => (b) => a < b ? a : b;

package/types/bigint/test.f.d.ts

@@ -1,10 +1,13 @@
+export declare const clz32Log2: (v: bigint) => bigint;
 declare const _default: {
     example: () => void;
-    benchmark: {
-        str: () => void;
-        stringHexLog2: () => void;
-        oldLog2: () => void;
-        log2: () => void;
+    benchmark: () => {
+        big: {
+            [k: string]: () => void;
+        };
+        small: {
+            [k: string]: () => void;
+        };
     };
     mask: () => void;
     sum: () => void;

package/types/bigint/test.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, min } from "./module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;
@@ -27,24 +27,83 @@ const oldLog2 = (v) => {
     }
     return result;
 };
-const stringLog2 = (v) => BigInt(v.toString(2).length) - 1n;
-const stringHexLog2 = (v) => {
+const strBinLog2 = (v) => BigInt(v.toString(2).length) - 1n;
+const strHexLog2 = (v) => {
     const len = (BigInt(v.toString(16).length) - 1n) << 2n;
-    const x = v >> len;
-    return len + 31n - BigInt(Math.clz32(Number(x)));
+    return len + 31n - BigInt(Math.clz32(Number(v >> len)));
 };
-const benchmark = (f) => () => {
+const str32Log2 = (v) => {
+    const len = (BigInt(v.toString(32).length) - 1n) * 5n;
+    return len + 31n - BigInt(Math.clz32(Number(v >> len)));
+};
+export const clz32Log2 = (v) => {
+    if (v <= 0n) {
+        return -1n;
+    }
+    let result = 31n;
+    let i = 32n;
+    while (true) {
+        const n = v >> i;
+        if (n === 0n) {
+            // overshot
+            break;
+        }
+        v = n;
+        result += i;
+        i <<= 1n;
+    }
+    // We know that `v` is not 0 so it doesn't make sense to check `n` when `i` is 0.
+    // Because of this, We check if `i` is greater than 32 before we divide it by 2.
+    while (i !== 32n) {
+        i >>= 1n;
+        const n = v >> i;
+        if (n !== 0n) {
+            result += i;
+            v = n;
+        }
+    }
+    return result - BigInt(Math.clz32(Number(v)));
+};
+const benchmark = f => () => {
     let e = 1048575n;
     let c = 1n << e;
-    for (let i = 0n; i < 1_000; ++i) {
-        const x = f(c);
-        if (x !== e) {
-            throw x;
+    for (let i = 0n; i < 1_100; ++i) {
+        {
+            const x = f(c);
+            if (x !== e) {
+                throw x;
+            }
+        }
+        {
+            const x = f(c - 1n);
+            if (x !== e - 1n) {
+                throw [e, x];
+            }
         }
         c >>= 1n;
         --e;
     }
 };
+const benchmarkSmall = f => () => {
+    let e = 2000n;
+    let c = 1n << e;
+    do {
+        {
+            const x = f(c);
+            if (x !== e) {
+                throw [e, x];
+            }
+        }
+        for (let j = 1n; j < min(c >> 1n)(1000n); ++j) {
+            const x = f(c - j);
+            if (x !== e - 1n) {
+                throw [j, e, x];
+            }
+        }
+        c >>= 1n;
+        --e;
+    } while (c !== 0n);
+};
 export default {
     example: () => {
         const total = sum([1n, 2n, 3n]); // 6n
@@ -53,26 +112,39 @@ export default {
         }
         const absoluteValue = abs(-42n); // 42n
         if (absoluteValue !== 42n) {
-            throw total;
+            throw absoluteValue;
         }
         const logValue = log2(8n); // 3n
         if (logValue !== 3n) {
-            throw total;
+            throw logValue;
         }
         const bitCount = bitLength(255n); // 8n
         if (bitCount !== 8n) {
-            throw total;
+            throw bitCount;
         }
         const bitmask = mask(5n); // 31n
         if (bitmask !== 31n) {
-            throw total;
+            throw benchmark;
+        }
+        const m = min(3n)(13n); // 3n
+        if (m !== 3n) {
+            throw m;
         }
     },
-    benchmark: {
-        str: benchmark(stringLog2),
-        stringHexLog2: benchmark(stringHexLog2),
-        oldLog2: benchmark(oldLog2),
-        log2: benchmark(log2),
+    benchmark: () => {
+        const list = {
+            strBinLog2,
+            strHexLog2,
+            str32Log2,
+            oldLog2,
+            clz32Log2,
+            log2,
+        };
+        const transform = (b) => Object.fromEntries(Object.entries(list).map(([k, f]) => [k, b(f)]));
+        return {
+            big: transform(benchmark),
+            small: transform(benchmarkSmall),
+        };
     },
     mask: () => {
         const result = mask(3n); // 7n