functionalscript 0.7.0 → 0.8.1

package/types/range_map/test.f.js

@@ -1,14 +1,14 @@
 import { get, merge, fromRange, rangeMap } from "./module.f.js";
-import { unsafeCmp } from "../function/compare/module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 import { union } from "../sorted_set/module.f.js";
 import { equal, toArray } from "../list/module.f.js";
-import * as operator from "../function/operator/module.f.js";
-const stringify = json.stringify(sort);
+import { strictEqual } from "../function/operator/module.f.js";
+import { cmp } from "../string/module.f.js";
+const str = stringify(sort);
 const op = {
-    union: union(unsafeCmp),
-    equal: equal(operator.strictEqual),
+    union: union(cmp),
+    equal: equal(strictEqual),
     def: []
 };
 export default {
@@ -56,7 +56,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2]];
             const b = null;
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -65,7 +65,7 @@ export default {
             const a = null;
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -74,7 +74,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['a'], 1], [['b'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a"],1],[["b"],2]]') {
                 throw result;
             }
@@ -83,7 +83,7 @@ export default {
             const a = [[['a'], 1], [['c'], 3]];
             const b = [[['b'], 2], [['d'], 4]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
             }
@@ -92,7 +92,7 @@ export default {
             const a = [[['a'], 1], [['d'], 4]];
             const b = [[['b'], 2], [['c'], 3]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') {
                 throw result;
             }
@@ -101,7 +101,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2]];
             const b = [[['b'], 1], [['a'], 2]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a","b"],2]]') {
                 throw result;
             }
@@ -110,7 +110,7 @@ export default {
             const a = [[['a'], 1], [['b'], 2], [['a'], 3]];
             const b = [[['a'], 5]];
             const merged = merge(op)(a)(b);
-            const result = stringify(toArray(merged));
+            const result = str(toArray(merged));
             if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') {
                 throw result;
             }
@@ -122,56 +122,56 @@ export default {
         return [
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(5)(rm));
+                const result = str(at(5)(rm));
                 if (result !== '["a"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(10)(rm));
+                const result = str(at(10)(rm));
                 if (result !== '["a"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(15)(rm));
+                const result = str(at(15)(rm));
                 if (result !== '["b"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(20)(rm));
+                const result = str(at(20)(rm));
                 if (result !== '["b"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(25)(rm));
+                const result = str(at(25)(rm));
                 if (result !== '["c"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(30)(rm));
+                const result = str(at(30)(rm));
                 if (result !== '["c"]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [[['a'], 10], [['b'], 20], [['c'], 30]];
-                const result = stringify(at(35)(rm));
+                const result = str(at(35)(rm));
                 if (result !== '[]') {
                     throw result;
                 }
             },
             () => {
                 const rm = [];
-                const result = stringify(at(10)(rm));
+                const result = str(at(10)(rm));
                 if (result !== '[]') {
                     throw result;
                 }

package/types/sorted_list/test.f.js

@@ -1,21 +1,21 @@
 import { find, merge } from "./module.f.js";
-import { unsafeCmp } from "../function/compare/module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 import { toArray, countdown, length } from "../list/module.f.js";
 import { flip } from "../function/module.f.js";
-const stringify = json.stringify(sort);
-const reverseCmp = flip(unsafeCmp);
+import { cmp } from "../number/module.f.js";
+const str = stringify(sort);
+const reverseCmp = flip(cmp);
 export default {
     sortedMergre: [
         () => {
-            const result = stringify(toArray(merge(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            const result = str(toArray(merge(cmp)([2, 3, 4])([1, 3, 5])));
             if (result !== '[1,2,3,4,5]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(merge(unsafeCmp)([1, 2, 3])([])));
+            const result = str(toArray(merge(cmp)([1, 2, 3])([])));
             if (result !== '[1,2,3]') {
                 throw result;
             }
@@ -32,25 +32,25 @@ export default {
     ],
     find: [
         () => {
-            const result = find(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 0) {
                 throw result;
             }
         },
         () => {
-            const result = find(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = find(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== null) {
                 throw result;
             }
         },
         () => {
-            const result = find(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = find(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result !== 80) {
                 throw result;
             }

package/types/sorted_set/test.f.js

@@ -1,22 +1,22 @@
 import { has, intersect, union } from "./module.f.js";
-import { unsafeCmp } from "../function/compare/module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 import { toArray, countdown, length } from "../list/module.f.js";
 import { flip } from "../function/module.f.js";
-const stringify = a => json.stringify(sort)(a);
-const reverseCmp = flip(unsafeCmp);
+import { cmp } from "../number/module.f.js";
+const str = a => stringify(sort)(a);
+const reverseCmp = flip(cmp);
 export default {
     example: () => {
         const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
         const setA = [1, 3, 5];
         const setB = [3, 4, 5];
         const unionSet = union(cmp)(setA)(setB); // [1, 3, 4, 5]
-        if (stringify(unionSet) !== '[1,3,4,5]') {
+        if (str(unionSet) !== '[1,3,4,5]') {
             throw 0;
         }
         const intersectionSet = intersect(cmp)(setA)(setB); // [3, 5]
-        if (stringify(intersectionSet) !== '[3,5]') {
+        if (str(intersectionSet) !== '[3,5]') {
             throw 1;
         }
         if (!has(cmp)(3)(setA)) {
@@ -28,13 +28,13 @@ export default {
     },
     union: [
         () => {
-            const result = stringify(toArray(union(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            const result = str(toArray(union(cmp)([2, 3, 4])([1, 3, 5])));
             if (result !== '[1,2,3,4,5]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(union(unsafeCmp)([1, 2, 3])([])));
+            const result = str(toArray(union(cmp)([1, 2, 3])([])));
             if (result !== '[1,2,3]') {
                 throw result;
             }
@@ -51,13 +51,13 @@ export default {
     ],
     intersect: [
         () => {
-            const result = stringify(toArray(intersect(unsafeCmp)([2, 3, 4])([1, 3, 5])));
+            const result = str(toArray(intersect(cmp)([2, 3, 4])([1, 3, 5])));
             if (result !== '[3]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(toArray(intersect(unsafeCmp)([1, 2, 3])([])));
+            const result = str(toArray(intersect(cmp)([1, 2, 3])([])));
             if (result !== '[]') {
                 throw result;
             }
@@ -65,25 +65,25 @@ export default {
     ],
     has: [
         () => {
-            const result = has(unsafeCmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = has(cmp)(0)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (!result) {
                 throw result;
             }
         },
         () => {
-            const result = has(unsafeCmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = has(cmp)(3)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = has(unsafeCmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = has(cmp)(77)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (result) {
                 throw result;
             }
         },
         () => {
-            const result = has(unsafeCmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
+            const result = has(cmp)(80)([0, 10, 20, 30, 40, 50, 60, 70, 80, 90]);
             if (!result) {
                 throw result;
             }

package/types/string/module.f.js

@@ -17,10 +17,10 @@
  */
 import { reduce as listReduce, repeat as listRepeat } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
-import { unsafeCmp } from "../function/compare/module.f.js";
+import { cmp as uCmp } from "../function/compare/module.f.js";
 import { join as joinOp, concat as concatOp } from "../function/operator/module.f.js";
 const reduce = o => listReduce(o)('');
 export const join = compose(joinOp)(reduce);
 export const concat = reduce(concatOp);
 export const repeat = v => compose(listRepeat(v))(concat);
-export const cmp = unsafeCmp;
+export const cmp = uCmp;

package/types/string_set/module.f.js

@@ -19,15 +19,15 @@
  * if (contains('banana')(mySet)) { throw '4' }
  * ```
  */
-import * as btree from "../btree/module.f.js";
+import { empty as btEmpty, values as btValues } from "../btree/module.f.js";
 import { find, isFound } from "../btree/find/module.f.js";
 import { remove as btreeRemove } from "../btree/remove/module.f.js";
 import { set as btreeSet } from "../btree/set/module.f.js";
 import { cmp } from "../string/module.f.js";
 import { fold } from "../list/module.f.js";
 import { compose } from "../function/module.f.js";
-export const values = btree.values;
-export const empty = btree.empty;
+export const values = btValues;
+export const empty = btEmpty;
 export const contains = value => {
     const f = find(cmp(value));
     return s => s !== null && isFound(f(s).first);

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

@@ -1,77 +0,0 @@
-/**
- * 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.
- */
-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

@@ -1,207 +0,0 @@
-/**
- * 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 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,8 +0,0 @@
-declare const _default: {
-    example: {
-        module: () => void;
-    };
-    classic: () => void;
-    map: () => void;
-};
-export default _default;