functionalscript 0.3.10 → 0.3.12

package/README.md

@@ -15,6 +15,7 @@ FunctionalScript is a safe, purely functional programming language and a strict
 [A working draft of the FunctionalScript specification](./issues/lang/README.md).
 
 Learn more about
+
 - [Purely Functional Programming in JavaScript](https://blog.bitsrc.io/purely-functional-programming-in-javascript-91114b1b2dff?sk=5f7132e56902f38fcf4c6164bfa681ed),
 - [FunctionalScript and I/O](https://medium.com/@sergeyshandar/functionalscript-5cf817345376?sk=30b32189a81d1a2dad16c2244f32328d).
 

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

@@ -0,0 +1,11 @@
+/**
+ * Rules for serializing and deserializing the BNF grammar.
+ *
+ * @module
+ */
+import type { TerminalRange } from '../module.f.ts';
+export type Sequence<Id> = readonly (TerminalRange | Id)[];
+export type Rule<Id> = readonly Sequence<Id>[];
+export type RuleMap<Id extends string> = {
+    readonly [k in Id]: Rule<Id>;
+};

package/bnf/djs/module.f.js

@@ -0,0 +1,6 @@
+/**
+ * Rules for serializing and deserializing the BNF grammar.
+ *
+ * @module
+ */
+export {};

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

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

package/bnf/djs/test.f.js

@@ -0,0 +1,221 @@
+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 = () => {
+    const map = {
+        json: [
+            ['element']
+        ],
+        value: [
+            ['object'],
+            ['array'],
+            ['string'],
+            ['number'],
+            s('true'),
+            s('false'),
+            s('null'),
+        ],
+        object: [
+            [c('{'), 'ws', c('}')],
+            [c('{'), 'members', c('}')],
+        ],
+        members: [
+            ['member'],
+            ['member', c(','), 'members'],
+        ],
+        member: [
+            ['ws', 'string', 'ws', c(':'), 'element'],
+        ],
+        array: [
+            [c('['), 'ws', c(']')],
+            [c('['), 'elements', c(']')],
+        ],
+        elements: [
+            ['element'],
+            ['element', c(','), 'elements'],
+        ],
+        element: [
+            ['ws', 'value', 'ws'],
+        ],
+        string: [
+            [c('"'), 'characters', c('"')],
+        ],
+        characters: [
+            [],
+            ['character', 'characters'],
+        ],
+        character: [
+            [[0x20, 0x21]], // exclude '"' 0x22
+            [[0x23, 0x5B]], // exclude '\' 0x5C
+            [[0x5D, 0x10FFFF]], // 93-1114111
+            [c('\\'), 'escape'], // 92
+        ],
+        escape: [
+            [c('"')],
+            [c('\\')],
+            [c('/')],
+            [c('b')],
+            [c('f')],
+            [c('n')],
+            [c('r')],
+            [c('t')],
+            [c('u'), 'hex', 'hex', 'hex', 'hex'],
+        ],
+        hex: [
+            ['digit'],
+            [[0x41, 0x46]], // A-F
+            [[0x61, 0x66]], // a-f
+        ],
+        number: [
+            ['integer', 'fraction', 'exponent'],
+        ],
+        integer: [
+            ['digit'],
+            ['onenine', 'digits'],
+            [c('-'), 'digit'],
+            [c('-'), 'onenine', 'digits'],
+        ],
+        digits: [
+            ['digit'],
+            ['digit', 'digits'],
+        ],
+        digit: [
+            [c('0')],
+            ['onenine'],
+        ],
+        onenine: [
+            [[0x31, 0x39]], // 1-9
+        ],
+        fraction: [
+            [],
+            [c('.'), 'digits'],
+        ],
+        exponent: [
+            [],
+            [c('E'), 'sign', 'digits'],
+            [c('e'), 'sign', 'digits'],
+        ],
+        sign: [
+            [],
+            [c('+')],
+            [c('-')],
+        ],
+        ws: [
+            [],
+            [c(' '), 'ws'],
+            [c('\n'), 'ws'],
+            [c('\r'), 'ws'],
+            [c('\t'), 'ws'],
+        ],
+    };
+    const _map = map;
+};
+const deterministic = () => {
+    const map = {
+        json: [
+            ['ws', 'element']
+        ],
+        value: [
+            [c('{'), 'ws', 'object', c('}')],
+            [c('['), 'ws', 'array', c(']')],
+            ['string'],
+            ['number'],
+            s('true'),
+            s('false'),
+            s('null'),
+        ],
+        object: [
+            [],
+            ['member', 'members'],
+        ],
+        members: [
+            [],
+            [c(','), 'ws', 'member', 'members'],
+        ],
+        member: [
+            ['string', 'ws', c(':'), 'ws', 'element'],
+        ],
+        array: [
+            [],
+            ['element', 'elements'],
+        ],
+        elements: [
+            [],
+            [c(','), 'ws', 'element', 'elements'],
+        ],
+        element: [
+            ['value', 'ws'],
+        ],
+        string: [
+            [c('"'), 'characters', c('"')],
+        ],
+        characters: [
+            [],
+            ['character', 'characters'],
+        ],
+        character: [
+            [[0x20, 0x21]], // exclude '"' 0x22
+            [[0x23, 0x5B]], // exclude '\' 0x5C
+            [[0x5D, 0x10FFFF]], // 93-1114111
+            [c('\\'), 'escape'], // 92
+        ],
+        escape: [
+            [c('"')],
+            [c('\\')],
+            [c('/')],
+            [c('b')],
+            [c('f')],
+            [c('n')],
+            [c('r')],
+            [c('t')],
+            [c('u'), 'hex', 'hex', 'hex', 'hex'],
+        ],
+        hex: [
+            ['digit'],
+            [[0x41, 0x46]], // A-F
+            [[0x61, 0x66]], // a-f
+        ],
+        number: [
+            ['integer', 'fraction', 'exponent'],
+            [c('-'), 'integer', 'fraction', 'exponent'],
+        ],
+        integer: [
+            [c('0')],
+            ['onenine', 'digits'],
+        ],
+        digits: [
+            [],
+            ['digit', 'digits'],
+        ],
+        digit: [
+            [c('0')],
+            ['onenine'],
+        ],
+        onenine: [
+            [[0x31, 0x39]], // 1-9
+        ],
+        fraction: [
+            [],
+            [c('.'), 'digit', 'digits'],
+        ],
+        exponent: [
+            [],
+            [c('E'), 'sign', 'digit', 'digits'],
+            [c('e'), 'sign', 'digit', 'digits'],
+        ],
+        sign: [
+            [],
+            [c('+')],
+            [c('-')],
+        ],
+        ws: [
+            [],
+            [c(' '), 'ws'],
+            [c('\n'), 'ws'],
+            [c('\r'), 'ws'],
+            [c('\t'), 'ws'],
+        ],
+    };
+    const _map = map;
+};

package/bnf/module.f.d.ts

@@ -0,0 +1,135 @@
+/**
+ *  Types for defining language grammars using Backus-Naur Form (BNF).
+ *
+ * @module
+ *
+ * @description
+ *
+ * The primary utility of this module is to define grammars for text processing,
+ * parsing, and lexing in a structured and reusable way.
+ *
+ * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
+ *
+ * @example
+ *
+ * ```js
+ * import { firstSet, type Rule, type Set } from './module.f.ts'
+ *
+ * const grammar: Rule = [
+ *     { or: [[65, 90], [97, 122], [48, 57]] }, // Matches 'A-Z', 'a-z', and '0-9'
+ * ];
+ *
+ * const s = firstSet(grammar)
+ * if (s.empty) { throw s }
+ * if (setOp.get('0'.codePointAt(0))(s.map) !== true) { throw s }
+ * if (setOp.get('h'.codePointAt(0))(s.map) !== true) { throw s }
+ * if (setOp.get('$'.codePointAt(0))(s.map) !== false) { throw s }
+ * ```
+ */
+import { type CodePoint } from '../text/utf16/module.f.ts';
+import { type RangeMapOp, type RangeMapArray } from '../types/range_map/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 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 = { or: [
+ *     id2,
+ *     digit,
+ * ] }
+ * ```
+ */
+export type Or = {
+    readonly or: Sequence;
+};
+/**
+ * Represents a grammar rule, which can be:
+ * - A sequence of rules (`Sequence`)
+ * - An "or" operation (`Or`)
+ * - A terminal range (`TerminalRange`)
+ * - A string (representing a literal sequence of characters)
+ *
+ * @remarks The rule can't have recursions.
+ *
+ * @example
+ *
+ * ```ts
+ * // Matches 'true', 'false'
+ * const bool: DataRule = { or: [
+ *    'true',
+ *    'false',
+ * ] }
+ */
+export type DataRule = Or | Sequence | TerminalRange | string;
+/**
+ * Represents a lazy grammar rule for recursive definitions.
+ *
+ * @example
+ *
+ * ```ts
+ * const alpha: TerminalRange = [65, 90]  // Matches 'A-Z'
+ * // Matches a string of uppercase letters
+ * const id: LazyRule = () => [alpha, { or: [
+ *     [],  // Empty
+ *     id   // Recursive
+ * ] }]
+ * ```
+ */
+export type LazyRule = () => DataRule;
+/**
+ * Represents a rule in the grammar.
+ */
+export type Rule = DataRule | LazyRule;
+export declare const toTerminalRangeSequence: (s: string) => readonly TerminalRange[];
+/**
+ * A set that represents possible code points.
+ */
+export type CpSet = {
+    /**
+     * Whether a grammar rule allows an empty sequence.
+     */
+    readonly empty: boolean;
+    /**
+     * The range map representing a set of possible code points.
+     */
+    readonly map: RangeMapArray<boolean>;
+};
+/**
+ * Operations on code point sets.
+ */
+export declare const setOp: RangeMapOp<boolean>;
+/**
+ * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
+ *
+ * @param rule - The grammar rule to process.
+ * @returns A set representing the first possible code points in the grammar rule.
+ */
+export declare const firstSet: (rule: Rule) => CpSet;

package/bnf/module.f.js

@@ -0,0 +1,142 @@
+/**
+ *  Types for defining language grammars using Backus-Naur Form (BNF).
+ *
+ * @module
+ *
+ * @description
+ *
+ * The primary utility of this module is to define grammars for text processing,
+ * parsing, and lexing in a structured and reusable way.
+ *
+ * See [Backus-Naur form](https://en.wikipedia.org/wiki/Backus%E2%80%93Naur_form).
+ *
+ * @example
+ *
+ * ```js
+ * import { firstSet, type Rule, type Set } from './module.f.ts'
+ *
+ * const grammar: Rule = [
+ *     { or: [[65, 90], [97, 122], [48, 57]] }, // Matches 'A-Z', 'a-z', and '0-9'
+ * ];
+ *
+ * const s = firstSet(grammar)
+ * if (s.empty) { throw s }
+ * if (setOp.get('0'.codePointAt(0))(s.map) !== true) { throw s }
+ * if (setOp.get('h'.codePointAt(0))(s.map) !== true) { throw s }
+ * if (setOp.get('$'.codePointAt(0))(s.map) !== false) { throw s }
+ * ```
+ */
+import { stringToCodePointList } from "../text/utf16/module.f.js";
+import { map, toArray } from "../types/list/module.f.js";
+import { rangeMap } from "../types/range_map/module.f.js";
+const toTerminalRangeMap = map((cp) => [cp, cp]);
+export const toTerminalRangeSequence = (s) => toArray(toTerminalRangeMap(stringToCodePointList(s)));
+/**
+ * Operations on code point sets.
+ */
+export const setOp = rangeMap({
+    union: a => b => a || b,
+    equal: a => b => a === b,
+    def: false
+});
+const { merge, fromRange } = setOp;
+const rangeToSet = (r) => ({ empty: false, map: fromRange(r)(true) });
+const isTerminalRange = (rule) => typeof rule[0] === 'number';
+const passSet = { empty: true, map: [] };
+/**
+ * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
+ *
+ * @param rule - The grammar rule to process.
+ * @returns A set representing the first possible code points in the grammar rule.
+ */
+export const firstSet = (rule) => {
+    if (typeof rule === 'function') {
+        rule = rule();
+    }
+    if (typeof rule === 'string') {
+        const first = toTerminalRangeSequence(rule).at(0);
+        if (first === undefined) {
+            return passSet;
+        }
+        return rangeToSet(first);
+    }
+    if (rule instanceof Array) {
+        if (isTerminalRange(rule)) {
+            return rangeToSet(rule);
+        }
+        let result = [];
+        for (const r of rule) {
+            const { empty, map } = firstSet(r);
+            result = toArray(merge(result)(map));
+            if (!empty) {
+                return { empty: false, map: result };
+            }
+        }
+        return { empty: true, map: result };
+    }
+    let empty = false;
+    let map = [];
+    for (const r of rule.or) {
+        const { empty: rEmpty, map: rMap } = firstSet(r);
+        map = toArray(merge(map)(rMap));
+        empty ||= rEmpty;
+    }
+    return { empty, map };
+};
+// type MatchMap = {
+//     empty: boolean
+//     map: RangeMapArray<MatchMap>
+// }
+// const defMatchMap: MatchMap = { empty: false, map: [] }
+// const unionMap = (a: MatchMap) => (b: MatchMap) =>
+//     ({ empty: a.empty || b.empty, map: toArray(matchMapOp.merge(a.map)(b.map)) })
+// /**
+//  * Operations on code point map.
+//  */
+// const matchMapOp: RangeMapOp<MatchMap> = rangeMap({
+//     union: unionMap,
+//     equal: a => b => a === b,
+//     def: defMatchMap
+// })
+// const { merge: mergeMap, fromRange: fromRangeMap } = matchMapOp
+// const pass: MatchMap = { empty: true, map: [] }
+// const rangeToMatchMap = (r: TerminalRange, p: MatchMap): MatchMap => ({ empty: false, map: fromRangeMap(r)(p) })
+// /**
+//  * Processes a `Rule` and converts it into a `Set` of possible code points at the start of the rule.
+//  *
+//  * @param rule - The grammar rule to process.
+//  * @returns A set representing the first possible code points in the grammar rule.
+//  */
+// export const matchMap = (rule: Rule): MatchMap => {
+//     if (typeof rule === 'function') {
+//         rule = rule()
+//     }
+//     if (typeof rule === 'string') {
+//         const a = toTerminalRangeSequence(rule)
+//         let result = pass
+//         for (const r of a) {
+//             result = rangeToMatchMap(r, result)
+//         }
+//         return result
+//     }
+//     if (rule instanceof Array) {
+//         if (isTerminalRange(rule)) {
+//             return rangeToMatchMap(rule, pass)
+//         }
+//         let result = pass
+//         for (const r of rule.toReversed()) {
+//             todo()
+//             /*
+//             const rMap = matchMap(r)
+//             result = unionMap(result)(rMap)
+//             */
+//         }
+//         return result
+//     }
+//     let result = pass
+//     for (const r of rule.or) {
+//         const rMap = matchMap(r)
+//         result = unionMap(result)(rMap)
+//     }
+//     return result
+// }

package/bnf/test.f.d.ts

@@ -0,0 +1,65 @@
+declare const _default: {
+    example: {
+        module: () => void;
+        types: () => void;
+    };
+    classic: () => {
+        ws: () => void;
+        sign: () => void;
+        digits: () => void;
+        exponent: () => void;
+        fraction: () => void;
+        onenine: () => void;
+        digit: () => void;
+        string: () => void;
+        member: () => void;
+        members: () => void;
+        object: () => void;
+        array: () => void;
+        integer: () => void;
+        number: () => void;
+        value: () => void;
+        element: () => void;
+        elements: () => void;
+        json: () => void;
+        hex: () => void;
+        escape: () => void;
+        character: () => void;
+        characters: () => void;
+    };
+    deterministic: () => {
+        ws: () => void;
+        sign: () => void;
+        digits1: () => void;
+        digits: () => void;
+        exponent: () => void;
+        fraction: () => void;
+        onenine: () => void;
+        digit: () => void;
+        string: () => void;
+        member1: () => void;
+        member: () => void;
+        members2: () => void;
+        members1: () => void;
+        members: () => void;
+        object1: () => void;
+        object: () => void;
+        array1: () => void;
+        array: () => void;
+        integer1: () => void;
+        integer: () => void;
+        number: () => void;
+        value: () => void;
+        element1: () => void;
+        element: () => void;
+        elements2: () => void;
+        elements1: () => void;
+        elements: () => void;
+        json: () => void;
+        hex: () => void;
+        escape: () => void;
+        character: () => void;
+        characters: () => void;
+    };
+};
+export default _default;