functionalscript 0.3.12 → 0.3.13

package/nanvm-lib/tests/test.f.d.ts

@@ -55,5 +55,38 @@ declare const _default: {
         };
         function: () => void;
     };
+    unary_minus: () => {
+        null: () => void;
+        undefined: () => void;
+        boolean: {
+            false: () => void;
+            true: () => void;
+        };
+        number: {
+            zero: () => void;
+            positive: () => void;
+            negative: () => void;
+        };
+        string: {
+            empty: () => void;
+            zero: () => void;
+            positive: () => void;
+            nan: () => void;
+        };
+        bigint: {
+            positive: () => void;
+            negative: () => void;
+        };
+        array: {
+            empty: () => void;
+            single_number: () => void;
+            single_string: () => void;
+            multiple: () => void;
+        };
+        object: {
+            empty: () => void;
+        };
+        function: () => void;
+    };
 };
 export default _default;

package/nanvm-lib/tests/test.f.js

@@ -10,6 +10,12 @@ const n = a => b => {
         throw [a, '!==', b];
     }
 };
+const nan_res = op => n => {
+    let result = op(n);
+    if (!Number.isNaN(result)) {
+        throw result;
+    }
+};
 export default {
     eq: {
         nullish: () => {
@@ -84,12 +90,7 @@ export default {
     },
     unary_plus: () => {
         const op = (n) => +n;
-        const nan = (n) => {
-            let result = op(n);
-            if (!Number.isNaN(result)) {
-                throw result;
-            }
-        };
+        const nan = nan_res(op);
         return {
             null: () => e(op(null))(0),
             undefined: () => nan(undefined),
@@ -123,5 +124,43 @@ export default {
             },
             function: () => nan(op(() => { }))
         };
+    },
+    unary_minus: () => {
+        const op = (n) => -n;
+        const nan = nan_res(op);
+        return {
+            null: () => e(op(null))(0),
+            undefined: () => nan(undefined),
+            boolean: {
+                false: () => e(op(false))(0),
+                true: () => e(op(true))(-1)
+            },
+            number: {
+                zero: () => e(op(0))(0),
+                positive: () => e(op(2.3))(-2.3),
+                negative: () => e(op(-2.3))(2.3)
+            },
+            string: {
+                empty: () => e(op(""))(0),
+                zero: () => e(op("0"))(0),
+                positive: () => e(op("2.3"))(-2.3),
+                nan: () => nan("a")
+            },
+            bigint: {
+                positive: () => e(op(1n))(-1n),
+                negative: () => e(op(-1n))(1n),
+            },
+            array: {
+                empty: () => e(op([]))(0),
+                single_number: () => e(op([2.3]))(-2.3),
+                single_string: () => e(op(["-2.3"]))(2.3),
+                multiple: () => nan([null, null])
+            },
+            object: {
+                empty: () => nan({})
+                // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
+            },
+            function: () => nan(op(() => { }))
+        };
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.3.12",
+  "version": "0.3.13",
   "type": "module",
   "files": [
     "**/*.f.d.ts",
@@ -11,11 +11,13 @@
     "tsc-emit": "tsc --NoEmit false",
     "prepack": "npm run tsc-emit",
     "test20": "npm run prepack && node --trace-uncaught ./dev/test.js",
-    "test": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
-    "comtest": "node --experimental-strip-types ./com/test/build.ts",
-    "index": "node --experimental-strip-types ./dev/index.ts",
-    "version": "node --experimental-strip-types ./nodejs/version/main.ts",
-    "fsc": "node --experimental-strip-types ./main.ts"
+    "test22": "tsc && node --experimental-strip-types --trace-uncaught ./dev/test.ts",
+    "test": "tsc && node --trace-uncaught ./dev/test.ts",
+    "comtest": "node ./com/test/build.ts",
+    "index": "node ./dev/index.ts",
+    "version": "node ./nodejs/version/main.ts",
+    "fsc": "node ./main.ts",
+    "update": "npm run version && npm run index && npm install"
   },
   "repository": {
     "type": "git",
@@ -37,7 +39,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.10.2",
+    "@types/node": "^22.10.5",
     "typescript": "^5.7.2"
   }
 }

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

@@ -1,3 +1,8 @@
+/**
+ * JavaScript immutable arrays.
+ *
+ * @module
+ */
 export type Array1<T> = readonly [T];
 export type Index1 = 0;
 export type Array2<T> = readonly [T, T];
@@ -5,16 +10,17 @@ export type Tuple2<T0, T1> = readonly [T0, T1];
 export type Index2 = 0 | 1;
 export type Array3<T> = readonly [T, T, T];
 export type Tuple3<T0, T1, T2> = readonly [T0, T1, T2];
-export type Index3 = 0 | 1 | 2;
+export type Index3 = Index2 | 2;
 export type Array4<T> = readonly [T, T, T, T];
-export type Index4 = 0 | 1 | 2 | 3;
+export type Index4 = Index3 | 3;
 export type Array5<T> = readonly [T, T, T, T, T];
+export type Index5 = Index4 | 4;
 export type Array8<T> = readonly [T, T, T, T, T, T, T, T];
+export type Index8 = Index5 | 5 | 6 | 7;
 export type Array16<T> = readonly [T, T, T, T, T, T, T, T, T, T, T, T, T, T, T, T];
-export type Index16 = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
+export type Index16 = Index8 | 8 | 9 | 10 | 11 | 12 | 13 | 14 | 15;
 export type Array1_5<T> = Array1<T> | Array2<T> | Array3<T> | Array4<T> | Array5<T>;
-export type Index5 = 0 | 1 | 2 | 3 | 4;
-export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends readonly (infer _)[] ? number : never;
+export type KeyOf<T> = T extends Array1<infer _> ? Index1 : T extends Array2<infer _> ? Index2 : T extends Array3<infer _> ? Index3 : T extends Array4<infer _> ? Index4 : T extends Array5<infer _> ? Index5 : T extends Array8<infer _> ? Index8 : T extends Array16<infer _> ? Index16 : T extends readonly (infer _)[] ? number : never;
 export declare const at: (i: number) => <T>(a: readonly T[]) => T | null;
 export declare const first: <T>(_: readonly T[]) => T | null;
 export declare const last: <T>(a: readonly T[]) => T | null;
@@ -22,3 +28,11 @@ export declare const tail: <T>(a: readonly T[]) => readonly T[] | null;
 export declare const splitFirst: <T>(a: readonly T[]) => readonly [T, readonly T[]] | null;
 export declare const head: <T>(a: readonly T[]) => readonly T[] | null;
 export declare const splitLast: <T>(a: readonly T[]) => readonly [readonly T[], T] | null;
+/**
+ * An empty immutable array.
+ *
+ * Two JavaScript empty arrays are different and has to have two different values.
+ * Usually, it requires memory allocation. If we use the same an empty array everywhere,
+ * we may minimize memory a number of memory allocations.
+ */
+export declare const empty: readonly [];

package/types/array/module.f.js

@@ -1,3 +1,8 @@
+/**
+ * JavaScript immutable arrays.
+ *
+ * @module
+ */
 import { map } from "../nullable/module.f.js";
 const uncheckTail = (a) => a.slice(1);
 const uncheckHead = (a) => a.slice(0, -1);
@@ -20,3 +25,11 @@ export const splitLast = (a) => {
     }
     return [uncheckHead(a), lastA];
 };
+/**
+ * An empty immutable array.
+ *
+ * Two JavaScript empty arrays are different and has to have two different values.
+ * Usually, it requires memory allocation. If we use the same an empty array everywhere,
+ * we may minimize memory a number of memory allocations.
+ */
+export const empty = [];

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

@@ -7,5 +7,6 @@ declare const _default: {
     tail: (() => void)[];
     splitFirst: (() => void)[];
     splitLast: (() => void)[];
+    empty: () => void;
 };
 export default _default;

package/types/array/test.f.js

@@ -1,4 +1,4 @@
-import { at, first, last, head, tail, splitFirst, splitLast } from "./module.f.js";
+import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
 const stringify = json.stringify(sort);
@@ -113,5 +113,14 @@ export default {
                 throw result;
             }
         }
-    ]
+    ],
+    empty: () => {
+        const x = empty;
+        const a = x;
+        const b = x;
+        const c = [...a, ...b, ...x];
+        if (c.length !== 0) {
+            throw c;
+        }
+    }
 };

package/bnf/module.f.d.ts

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

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

@@ -1,65 +0,0 @@
-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;