functionalscript 0.8.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/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;