functionalscript 0.7.0 → 0.8.1

package/bnf/djs/test.f.js

@@ -1,277 +0,0 @@
-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";
-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']
-        ],
-        value: [
-            ['object'],
-            ['array'],
-            ['string'],
-            ['number'],
-            str('true'),
-            str('false'),
-            str('null'),
-        ],
-        object: [
-            [cp('{'), 'ws', cp('}')],
-            [cp('{'), 'members', cp('}')],
-        ],
-        members: [
-            ['member'],
-            ['member', cp(','), 'members'],
-        ],
-        member: [
-            ['ws', 'string', 'ws', cp(':'), 'element'],
-        ],
-        array: [
-            [cp('['), 'ws', cp(']')],
-            [cp('['), 'elements', cp(']')],
-        ],
-        elements: [
-            ['element'],
-            ['element', cp(','), 'elements'],
-        ],
-        element: [
-            ['ws', 'value', 'ws'],
-        ],
-        string: [
-            [cp('"'), 'characters', cp('"')],
-        ],
-        characters: [
-            [],
-            ['character', 'characters'],
-        ],
-        character: [
-            ...remove([0x20, 0x10FFFF], [cp('"'), cp('\\')]),
-            [cp('\\'), 'escape'], // 92
-        ],
-        escape: [
-            str('"'),
-            str('\\'),
-            str('/'),
-            str('b'),
-            str('f'),
-            str('n'),
-            str('r'),
-            str('t'),
-            [cp('u'), 'hex', 'hex', 'hex', 'hex'],
-        ],
-        hex: [
-            ['digit'],
-            [range('AF')], // A-F
-            [range('af')], // a-f
-        ],
-        number: [
-            ['integer', 'fraction', 'exponent'],
-        ],
-        integer: [
-            ['digit'],
-            ['onenine', 'digits'],
-            [cp('-'), 'digit'],
-            [cp('-'), 'onenine', 'digits'],
-        ],
-        digits: [
-            ['digit'],
-            ['digit', 'digits'],
-        ],
-        digit: [
-            [cp('0')],
-            ['onenine'],
-        ],
-        onenine: [
-            [range('19')],
-        ],
-        fraction: [
-            [],
-            [cp('.'), 'digits'],
-        ],
-        exponent: [
-            [],
-            [cp('E'), 'sign', 'digits'],
-            [cp('e'), 'sign', 'digits'],
-        ],
-        sign: [
-            [],
-            [cp('+')],
-            [cp('-')],
-        ],
-        ws: [
-            [],
-            [cp(' '), 'ws'],
-            [cp('\n'), 'ws'],
-            [cp('\r'), 'ws'],
-            [cp('\t'), 'ws'],
-        ],
-    };
-    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: [
-            ['wsRepeat0', 'element']
-        ],
-        value: [
-            [cp('{'), 'wsRepeat0', 'object', cp('}')],
-            [cp('['), 'wsRepeat0', 'array', cp(']')],
-            ['string'],
-            ['number'],
-            str('true'),
-            str('false'),
-            str('null'),
-        ],
-        object: [
-            [],
-            ['member', 'memberTailRepeat0'],
-        ],
-        memberTail: [
-            [cp(','), 'wsRepeat0', 'member']
-        ],
-        ...repeat0('memberTail'),
-        member: [
-            ['string', 'wsRepeat0', cp(':'), 'wsRepeat0', 'element'],
-        ],
-        array: [
-            [],
-            ['element', 'elements'],
-        ],
-        elements: [
-            [],
-            [cp(','), 'wsRepeat0', 'element', 'elements'],
-        ],
-        element: [
-            ['value', 'wsRepeat0'],
-        ],
-        string: [
-            [cp('"'), 'characterRepeat0', cp('"')],
-        ],
-        ...repeat0('character'),
-        character: [
-            ...remove([0x20, 0x10FFFF], [cp('"'), cp('\\')]),
-            [cp('\\'), 'escape'], // 92
-        ],
-        escape: [
-            ...set('"\\/bfnrt'),
-            [cp('u'), 'hex', 'hex', 'hex', 'hex'],
-        ],
-        hex: [
-            ['digit'],
-            [range('AF')],
-            [range('af')],
-        ],
-        numberSign: [
-            [],
-            [cp('-')]
-        ],
-        number: [
-            ['numberSign', 'integer', 'fraction', 'exponent'],
-        ],
-        integer: [
-            [cp('0')],
-            ['onenine', 'digitRepeat0'],
-        ],
-        ...repeat0('digit'),
-        digit: [
-            [cp('0')],
-            ['onenine'],
-        ],
-        onenine: [
-            [range('19')],
-        ],
-        fraction: [
-            [],
-            [cp('.'), 'digit', 'digitRepeat0'],
-        ],
-        e: set('Ee'),
-        exponent: [
-            [],
-            ['e', 'sign', 'digit', 'digitRepeat0'],
-        ],
-        sign: [
-            [],
-            [cp('+')],
-            [cp('-')],
-        ],
-        ws: set(' \n\r\t'),
-        ...repeat0('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);
-    }
-};

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

@@ -1,148 +0,0 @@
-/**
- * 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
- * import type { Rule } from './module.f.ts'
- *
- * // Matches 'A-Z', 'a-z', and '0-9'
- * const grammar: Rule = () => [
- *     [[65, 90]],
- *     [[97, 122]],
- *     [[48, 57]],
- * ]
- * ```
- */
-import { type CodePoint } from '../../text/utf16/module.f.ts';
-/**
- * Represents a terminal range as a pair of Unicode code points.
- * Typically used to define character ranges.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * ```
- */
-export type TerminalRange = readonly [CodePoint, CodePoint];
-/**
- * Represents a sequence of rules that must match in order.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * const id2: Sequence = [alpha, alpha]  // Matches two uppercase letters
- * ```
- */
-export type Sequence = readonly (TerminalRange | Rule)[];
-/**
- * Represents a logical "or" operation between multiple sequences.
- * Allows defining alternatives within the grammar.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90] // Matches 'A-Z'
- * const id2: Sequence = [alpha, alpha]  // Matches two uppercase letters
- * const digit: TerminalRange = [48, 57] // Matches '0-9'
- * // Matches two uppercase letters or one digit
- * const id2OrDigit: Or = [
- *     id2,
- *     [digit],
- * ]
- * ```
- */
-export type Or = readonly Sequence[];
-/**
- * Represents a lazy grammar rule for recursive definitions.
- *
- * @example
- *
- * ```ts
- * const alpha: TerminalRange = [65, 90]  // Matches 'A-Z'
- * // zero or more alpha symbols
- * const alpha0x: Rule = () => [
- *     [],              // Empty
- *     [alpha, alpha0x] // Recursive
- * ]
- * const id: Sequence = [alpha, alpha0x]
- * ```
- */
-export type Rule = () => Or;
-/**
- * Converts a string to an array of terminal ranges where each character is a separate range.
- *
- * @param s - The input string.
- * @returns An array of terminal ranges representing each character in the string.
- *
- * @example
- *
- * ```ts
- * const ranges = str('abc') // [[97, 97], [98, 98], [99, 99]]
- * ```
- */
-export declare const str: (s: string) => readonly TerminalRange[];
-/**
- * Converts a single character string to a terminal range.
- *
- * @param a - The input character string.
- * @returns A terminal range representing the character.
- *
- * @example
- * ```ts
- * const range = cp('A'); // [65, 65]
- * ```
- */
-export declare const cp: (a: string) => TerminalRange;
-/**
- * Converts a two-character string into a terminal range.
- *
- * @param ab - The input string of two characters.
- * @returns A terminal range representing the two characters.
- *
- * @throws {number} Throws an error if the input string does not have exactly two code points.
- *
- * @example
- * ```ts
- * const result = range('AZ'); // [65, 90]
- * ```
- */
-export declare const range: (ab: string) => TerminalRange;
-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.
- *
- * @param range the original range.
- * @param removeSet the set of ranges to be removed.
- * @returns The resulting set of ranges after removal.
- *
- * @example
- *
- * ```ts
- * const result = remove([65, 90], [cp('C'), cp('W')]) // [A..Z] w/o C and W
- * ```
- */
-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,132 +0,0 @@
-/**
- * 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
- * import type { Rule } from './module.f.ts'
- *
- * // Matches 'A-Z', 'a-z', and '0-9'
- * const grammar: Rule = () => [
- *     [[65, 90]],
- *     [[97, 122]],
- *     [[48, 57]],
- * ]
- * ```
- */
-import { stringToCodePointList } from "../../text/utf16/module.f.js";
-import { map, toArray } from "../../types/list/module.f.js";
-import { one } from "../../types/range/module.f.js";
-const toTerminalRangeMap = map(one);
-/**
- * Converts a string to an array of terminal ranges where each character is a separate range.
- *
- * @param s - The input string.
- * @returns An array of terminal ranges representing each character in the string.
- *
- * @example
- *
- * ```ts
- * const ranges = str('abc') // [[97, 97], [98, 98], [99, 99]]
- * ```
- */
-export const str = (s) => toArray(toTerminalRangeMap(stringToCodePointList(s)));
-/**
- * Converts a single character string to a terminal range.
- *
- * @param a - The input character string.
- * @returns A terminal range representing the character.
- *
- * @example
- * ```ts
- * const range = cp('A'); // [65, 65]
- * ```
- */
-export const cp = (a) => one(a.codePointAt(0));
-/**
- * Converts a two-character string into a terminal range.
- *
- * @param ab - The input string of two characters.
- * @returns A terminal range representing the two characters.
- *
- * @throws {number} Throws an error if the input string does not have exactly two code points.
- *
- * @example
- * ```ts
- * const result = range('AZ'); // [65, 90]
- * ```
- */
-export const range = (ab) => {
-    const a = toArray(stringToCodePointList(ab));
-    if (a.length !== 2) {
-        throw a.length;
-    }
-    // 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) {
-        if (a0 < a) {
-            // [a0
-            //     ]a
-            result = [...result, [a0, Math.min(b0, a - 1)]];
-        }
-        if (b < b0) {
-            //    b0]
-            // b[
-            result = [...result, [Math.max(b + 1, a0), b0]];
-        }
-    }
-    return result;
-};
-/**
- * Removes a terminal range from a set of ranges.
- *
- * @param range the original range.
- * @param removeSet the set of ranges to be removed.
- * @returns The resulting set of ranges after removal.
- *
- * @example
- *
- * ```ts
- * const result = remove([65, 90], [cp('C'), cp('W')]) // [A..Z] w/o C and W
- * ```
- */
-export const remove = (range, removeSet) => {
-    let result = [range];
-    for (const r of removeSet) {
-        result = removeOne(result, r);
-    }
-    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.d.ts

@@ -1,12 +0,0 @@
-declare const _default: {
-    example: {
-        module: () => void;
-        types: () => void;
-        str: () => void;
-        cp: () => void;
-        range: () => void;
-        remove: () => void;
-    };
-    remove: () => void;
-};
-export default _default;