functionalscript 0.3.11 → 0.3.13

package/fsm/module.f.js

@@ -17,7 +17,7 @@ export const toUnion = s => {
     const codePoints = stringToList(s);
     return fold(toUnionOp)(empty)(codePoints);
 };
-const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual) };
+const mergeOp = { union: sortedSetUnion(unsafeCmp), equal: equal(strictEqual), def: [] };
 const hasState = s => set => !isEmpty(intersect(unsafeCmp)([s])(set));
 const foldOp = set => ([ruleIn, bs, ruleOut]) => rm => {
     if (hasState(ruleIn)(set)) {

package/issues/31-json.f.d.ts

@@ -0,0 +1 @@
+type TerminalRange = readonly [number, number];

package/issues/31-json.f.js

@@ -0,0 +1,241 @@
+"use strict";
+// JSON: https://www.json.org/json-en.html
+{
+    // null, [0x09, 0x0A], 0x0D, 0x20
+    const ws = () => ({ or: [
+            [],
+            ['\t', ws], // 0x09
+            ['\n', ws], // 0x0A
+            ['\r', ws], // 0x0D
+            [' ', ws], // 0x20
+        ] });
+    // null, 0x2B, 0x2D
+    const sign = { or: [
+            [],
+            '+', // 0x2B
+            '-', // 0x2D
+        ] };
+    // null, [0x30, 0x39]
+    const digits1 = () => ({ or: [
+            [],
+            digits // [0x30, 0x39]
+        ] });
+    // [0x30, 0x39]
+    const digits = () => [digit, digits1];
+    // null, 0x45, 0x65
+    const exponent = { or: [
+            [],
+            ['E', sign, digits], // 0x45
+            ['e', sign, digits], // 0x65
+        ] };
+    // null, 0x2E
+    const fraction = { or: [
+            [],
+            ['.', digits] // 0x2E
+        ] };
+    // [0x31, 0x39]
+    const onenine = [0x31, 0x39];
+    // [0x30, 0x39]
+    const digit = { or: [
+            '0', // 0x30
+            onenine, // [0x31, 0x39]
+        ] };
+    // null, 0x2C
+    const members2 = () => ({ or: [
+            [],
+            [',', ws, members1], // 0x2C
+        ] });
+    // 0x22
+    const members1 = () => [member1, members2];
+    // 0x22, 0x7D
+    const object1 = { or: [
+            [members1, '}'], // 0x22
+            '}', // 0x7D
+        ] };
+    // 0x7B
+    const object = ['{', ws, object1];
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x5D, 0x66, 0x6E, 0x74, 0x7B
+    const array1 = () => ({ or: [
+            [element1, ']'], // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+            ']', // 0x5D
+        ] });
+    // 0x5B
+    const array = ['[', ws, array1];
+    // [0x30, 0x39], [0x41, 0x46], [0x61, 0x66]
+    const hex = { or: [
+            digit, // [0x30, 0x39]
+            [0x41, 0x46], // A..F
+            [0x61, 0x66], // a..f
+        ] };
+    // 0x22, 0x2F, 0x5C, 0x62, 0x66, 0x6E, 0x72, [0x74, 0x75]
+    const escape = { or: [
+            '"', // 0x22
+            '/', // 0x2F
+            '\\', // 0x5C
+            'b', // 0x62
+            'f', // 0x66
+            'n', // 0x6E
+            'r', // 0x72
+            't', // 0x74
+            ['u', hex, hex, hex, hex] // 0x75
+        ] };
+    // [0x20, 0x21], [0x23, 0x10FFFF]
+    const character = { or: [
+            [0x20, 0x21], // exclude '"' 0x22
+            [0x23, 0x5B], // exclude '\' 0x5C
+            [0x5D, 0x10FFFF], //
+            ['\\', escape], // 0x5C
+        ] };
+    // null, [0x20, 0x21], [0x23, 0x10FFFF]
+    const characters = () => ({ or: [
+            [],
+            [character, characters]
+        ] });
+    // 0x22
+    const string = ['"', characters, '"'];
+    // [0x30, 0x39]
+    const integer1 = { or: [
+            '0',
+            [onenine, digits1],
+        ] };
+    // 0x2D, [0x30, 0x39]
+    const integer = { or: [
+            ['-', integer1], // 0x2D
+            '0', // 0x30
+            [onenine, digits1], // [0x31, 0x39]
+        ] };
+    // 0x2D, [0x30, 0x39]
+    const number = [integer, fraction, exponent];
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const value = { or: [
+            string, // 0x22
+            number, // 0x2D, [0x30, 0x39]
+            array, // 0x5B
+            'false', // 0x66
+            'null', // 0x6E
+            'true', // 0x74
+            object, // 0x7B
+        ] };
+    // 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const element1 = [value, ws];
+    // [0x09, 0x0A], 0x0D, 0x20, 0x22, 0x2D, [0x30, 0x39], 0x5B, 0x66, 0x6E, 0x74, 0x7B
+    const element = [ws, element1];
+    // 0x22
+    const member1 = [string, ws, ':', element];
+    const json = element;
+}
+// serializable
+{
+    //
+    const element = { id: 'element' };
+    const ws = { id: 'ws' };
+    const value = { id: 'value' };
+    const object = { id: 'object' };
+    const array = { id: 'array' };
+    const string = { id: 'string' };
+    const number = { id: 'number' };
+    const members = { id: 'members' };
+    const characters = { id: 'characters' };
+    const integer = { id: 'integer' };
+    const fraction = { id: 'fraction' };
+    const exponent = { id: 'exponent' };
+    const member = { id: 'member' };
+    const character = { id: 'character' };
+    const digit = { id: 'digit' };
+    const onenine = { id: 'onenine' };
+    const digits = { id: 'digits' };
+    const sign = { id: 'sign' };
+    const escape = { id: 'escape' };
+    const hex = { id: 'hex' };
+    const map = {
+        json: element,
+        element: [ws, value, ws],
+        ws: { or: [
+                [],
+                [' ', ws],
+                ['\t', ws],
+                ['\n', ws],
+                ['\r', ws],
+            ] },
+        value: { or: [
+                object,
+                array,
+                string,
+                number,
+                'true',
+                'false',
+                'null'
+            ] },
+        object: { or: [
+                ['{', ws, '}'],
+                ['{', members, '}'],
+            ] },
+        array: { or: [
+                ['[', ws, ']'],
+                ['[', element, ']'],
+            ] },
+        string: ['"', characters, '"'],
+        number: [integer, fraction, exponent],
+        members: { or: [
+                member,
+                [member, ',', members],
+            ] },
+        characters: { or: [
+                [],
+                [character, characters]
+            ] },
+        integer: { or: [
+                digit,
+                [onenine, digits],
+                ['-', digit],
+                ['-', onenine, digits],
+            ] },
+        fraction: { or: [
+                [],
+                ['.', digits]
+            ] },
+        exponent: { or: [
+                [],
+                ['E', sign, digits],
+                ['e', sign, digits],
+            ] },
+        member: [ws, string, ws, ':', element],
+        character: { or: [
+                [0x20, 0x21], // exclude '"' 0x22
+                [0x23, 0x5B], // exclude '\' 0x5C
+                [0x5D, 0x10FFFF],
+                ['\\', escape],
+            ] },
+        digit: { or: [
+                '0',
+                onenine,
+            ] },
+        onenine: [0x31, 0x39],
+        digits: { or: [
+                digit,
+                [digit, digits]
+            ] },
+        sign: { or: [
+                [],
+                '+',
+                '-',
+            ] },
+        escape: { or: [
+                '"',
+                '\\',
+                '/',
+                'b',
+                'f',
+                'n',
+                'r',
+                't',
+                ['u', hex, hex, hex, hex]
+            ] },
+        hex: { or: [
+                digit,
+                [0x41, 0x46], // A..F
+                [0x61, 0x66], // a..f
+            ] },
+    };
+    const _map = map;
+}

package/js/tokenizer/module.f.js

@@ -107,6 +107,7 @@ const union = def => a => b => {
 const rangeMapMerge = def => merge({
     union: union(def),
     equal: operator.strictEqual,
+    def,
 });
 const rangeFunc = r => f => def => fromRange(def)(r)(f);
 const scanRangeOp = def => f => [f(def), scanRangeOp(def)];
@@ -126,7 +127,11 @@ const create = (def) => (a) => {
 };
 const digitToBigInt = d => BigInt(d - digit0);
 const startNumber = digit => ({ s: 1n, m: digitToBigInt(digit), f: 0, es: 1, e: 0 });
-const startNegativeNumber = { s: -1n, m: 0n, f: 0, es: 1, e: 0 };
+/*
+const startNegativeNumber
+    : ParseNumberBuffer
+    = { s: -1n, m: 0n, f: 0, es: 1, e: 0 }
+*/
 const addIntDigit = digit => b => ({ ...b, m: b.m * 10n + digitToBigInt(digit) });
 const addFracDigit = digit => b => ({ ...b, m: b.m * 10n + digitToBigInt(digit), f: b.f - 1 });
 const addExpDigit = digit => b => ({ ...b, e: b.e * 10 + digit - digit0 });

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

@@ -41,6 +41,42 @@ declare const _default: {
             positive: () => void;
             nan: () => void;
         };
+        bigint: {
+            throw: () => number;
+        };
+        array: {
+            empty: () => void;
+            single_number: () => void;
+            single_string: () => void;
+            multiple: () => void;
+        };
+        object: {
+            empty: () => void;
+        };
+        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;
@@ -50,6 +86,7 @@ declare const _default: {
         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),
@@ -108,11 +109,9 @@ export default {
                 positive: () => e(op("2.3"))(2.3),
                 nan: () => nan("a")
             },
-            // TODO: bigint - handle TypeError exception for bigint. The test below (that follows
-            // current Rust implementation) is incorrect.
-            // bigint: {
-            //     nan: () => u_p_nan(0n)
-            // }
+            bigint: {
+                throw: () => op(0n),
+            },
             array: {
                 empty: () => e(op([]))(0),
                 single_number: () => e(op([2.3]))(2.3),
@@ -122,8 +121,46 @@ export default {
             object: {
                 empty: () => nan({})
                 // TODO: test objects with valueOf, toString functions - when Rust logic is implemented
-            }
-            // TODO: test Function - when Rust logic is implemented
+            },
+            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.11",
+  "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/text/module.f.js

@@ -1,7 +1,7 @@
 import { msb, u8List, u8ListToVec } from "../types/bit_vec/module.f.js";
 import { flatMap } from "../types/list/module.f.js";
 import * as utf8 from "./utf8/module.f.js";
-import * as utf16 from "./utf16/module.f.js";
+import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
 export const flat = (indent) => {
     const f = (prefix) => {
         const g = (item) => typeof (item) === 'string' ? [`${prefix}${item}`] : f(`${prefix}${indent}`)(item);
@@ -16,11 +16,11 @@ export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(utf16.toCodePointList(utf16.stringToList(s))));
+export const msbUtf8 = (s) => u8ListToVec(msb)(utf8.fromCodePointList(stringToCodePointList(s)));
 /**
  * Converts a UTF-8 bit vector with MSB first encoding to a string.
  *
  * @param msbV - The UTF-8 bit vector with MSB first encoding.
  * @returns The resulting string.
  */
-export const msbUtf8ToString = (msbV) => utf16.listToString(utf16.fromCodePointList(utf8.toCodePointList(u8List(msb)(msbV))));
+export const msbUtf8ToString = (msbV) => codePointListToString(utf8.toCodePointList(u8List(msb)(msbV)));

package/text/utf16/module.f.d.ts

@@ -1,8 +1,14 @@
 import { type List, type Thunk } from '../../types/list/module.f.ts';
-type U16 = number;
-type I32 = number;
-export declare const fromCodePointList: (input: List<number>) => Thunk<number>;
-export declare const toCodePointList: (input: List<U16>) => List<I32>;
+export type U16 = number;
+/**
+ * [0, 0x10_FFFF]: 16+5 = 21 bits
+ *
+ * 121_0000_0000: 16+16+9 = 41 bits
+ */
+export type CodePoint = number;
+export declare const fromCodePointList: (input: List<CodePoint>) => Thunk<U16>;
+export declare const toCodePointList: (input: List<U16>) => List<CodePoint>;
 export declare const stringToList: (s: string) => List<U16>;
+export declare const stringToCodePointList: (input: string) => List<CodePoint>;
 export declare const listToString: (input: List<U16>) => string;
-export {};
+export declare const codePointListToString: (input: List<CodePoint>) => string;

package/text/utf16/module.f.js

@@ -60,6 +60,8 @@ export const stringToList = (s) => {
     };
     return at(0);
 };
+export const stringToCodePointList = (input) => toCodePointList(stringToList(input));
 export const listToString = fn(map(String.fromCharCode))
     .then(reduce(concat)(''))
     .result;
+export const codePointListToString = (input) => listToString(fromCodePointList(input));

package/text/utf16/test.f.js

@@ -1,4 +1,4 @@
-import { toCodePointList, fromCodePointList, stringToList, listToString } from "./module.f.js";
+import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
 import * as json from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
@@ -130,6 +130,13 @@ export default {
                 throw result;
             }
         },
+        () => {
+            const cpList = stringToCodePointList("Hello world!😂🚜🚲");
+            const result = codePointListToString(cpList);
+            if (result !== "Hello world!😂🚜🚲") {
+                throw result;
+            }
+        },
         () => {
             const a = stringToList("Hello world!😂🚜🚲");
             const b = toCodePointList(a);

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;
+        }
+    }
 };