functionalscript 0.6.11 → 0.8.0

package/bnf/module.f.d.ts

@@ -1,9 +1,10 @@
 import { type Array2 } from '../types/array/module.f.ts';
 /**
- * A range of symbols (48 bits)
+ * A range of symbols. Two 24-bit numbers are stored in one JS number (48 bits).
+ *
  * For example: 0xBBBBBB_EEEEEE
- * - 0xBBBBBB is the first symbol
- * - 0xEEEEEE is the last symbol
+ * - 0xBBBBBB is the first symbol (24 bits)
+ * - 0xEEEEEE is the last symbol (24 bits)
  */
 export type TerminalRange = number;
 /** A sequence of rules. */
@@ -34,8 +35,8 @@ export declare const remove: (range: TerminalRange, removeSet: RangeVariant) =>
 export type None = readonly [];
 export declare const none: None;
 export type Option<S> = {
-    none: None;
     some: S;
+    none: None;
 };
 export declare const option: <S extends Rule>(some: S) => Option<S>;
 export type Repeat0Plus<T> = () => Option<readonly [T, Repeat0Plus<T>]>;

package/bnf/module.f.js

@@ -69,8 +69,8 @@ export const remove = (range, removeSet) => {
 };
 export const none = [];
 export const option = (some) => ({
-    none,
     some,
+    none,
 });
 /**
  * Repeat zero or more times.

package/bnf/testlib.f.js

@@ -130,8 +130,8 @@ export const deterministic = () => {
         close,
     ];
     const value = () => ({
-        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
         array: commaJoin0Plus('[]', value),
+        object: commaJoin0Plus('{}', [string, ws, ':', ws, value]),
         string,
         number,
         true: 'true',

package/dev/test.f.js

@@ -18,7 +18,7 @@ export default {
     ctorUndefined: () => {
         /** @type {any} */
         const o = {
-            constructor: void 0
+            constructor: undefined
         };
         const c = o['constructor'];
         //console.log(c)

package/dev/tf/all.test.js

@@ -0,0 +1,43 @@
+import { io } from "../../io/module.js";
+import { loadModuleMap } from "../module.f.js";
+import { isTest, parseTestSet } from "./module.f.js";
+import * as nodeTest from 'node:test';
+const isBun = typeof Bun !== 'undefined';
+const createFramework = (fw) => (prefix, f) => fw.test(prefix, t => f((name, v) => t.test(name, v)));
+const createBunFramework = (fw) => (prefix, f) => f((name, v) => fw.test(`${prefix}: ${name}`, v));
+const framework = isBun ? createBunFramework(nodeTest) : createFramework(nodeTest);
+const parse = parseTestSet(io.tryCatch);
+const scanModule = (x) => async (subTestRunner) => {
+    let subTests = [x];
+    while (true) {
+        const [first, ...rest] = subTests;
+        if (first === undefined) {
+            break;
+        }
+        subTests = rest;
+        //
+        const [name, value] = first;
+        const set = parse(value);
+        if (typeof set === 'function') {
+            await subTestRunner(name, () => {
+                const r = set();
+                subTests = [...subTests, [`${name}()`, r]];
+            });
+        }
+        else {
+            for (const [j, y] of set) {
+                const pr = `${name}/${j}`;
+                subTests = [...subTests, [pr, y]];
+            }
+        }
+    }
+};
+const run = async () => {
+    const x = await loadModuleMap(io);
+    for (const [i, v] of Object.entries(x)) {
+        if (isTest(i)) {
+            framework(i, scanModule(['', v.default]));
+        }
+    }
+};
+await run();

package/dev/{test → tf}/module.f.d.ts

@@ -1,6 +1,6 @@
 import { type CsiConsole } from '../../text/sgr/module.f.ts';
 import type * as Result from '../../types/result/module.f.ts';
-import type { Io, Performance } from '../../io/module.f.ts';
+import type { Io, Performance, TryCatch } from '../../io/module.f.ts';
 import { type ModuleMap } from '../module.f.ts';
 type Log<T> = CsiConsole;
 type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
@@ -14,6 +14,9 @@ type Input<T> = {
     readonly env: (n: string) => string | undefined;
 };
 export declare const isTest: (s: string) => boolean;
+export type Test = () => unknown;
+export type TestSet = Test | readonly (readonly [string, unknown])[];
+export declare const parseTestSet: (t: TryCatch) => (x: unknown) => TestSet;
 export declare const test: <T>(input: Input<T>) => readonly [number, T];
 export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
 export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];

package/dev/{test → tf}/module.f.js

@@ -13,49 +13,71 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
+export const parseTestSet = (t) => (x) => {
+    switch (typeof x) {
+        case 'function': {
+            if (x.length === 0) {
+                const xt = x;
+                if (xt.name !== 'throw') {
+                    return xt;
+                }
+                // Usual tests throw on error, but if the function name is 'throw',
+                // then the test passes if it throws.
+                return () => {
+                    const [tag, value] = t(xt);
+                    if (tag === 'ok') {
+                        throw value;
+                    }
+                    return value;
+                };
+            }
+            break;
+        }
+        case 'object': {
+            if (x !== null) {
+                return Object.entries(x);
+            }
+            break;
+        }
+    }
+    return [];
+};
 export const test = (input) => {
     let { moduleMap, log, error, measure, tryCatch, env, state } = input;
     const isGitHub = env('GITHUB_ACTION') !== undefined;
+    const parse = parseTestSet(tryCatch);
     const f = ([k, v]) => {
         const test = i => v => ([ts, state]) => {
             const next = test(`${i}| `);
-            switch (typeof v) {
-                case 'function': {
-                    if (v.length === 0) {
-                        const [[s, r], delta, state0] = measure(() => tryCatch(v))(state);
-                        state = state0;
-                        // Usual tests throw on error, but if the function name is 'throw', then the test passes if it throws.
-                        if ((s === 'error') === (v.name !== 'throw')) {
-                            ts = addFail(delta)(ts);
-                            if (isGitHub) {
-                                // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
-                                // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
-                                error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
-                            }
-                            else {
-                                error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
-                                error(`${fgRed}${r}${reset}`);
-                            }
-                        }
-                        else {
-                            ts = addPass(delta)(ts);
-                            log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
-                        }
-                        [ts, state] = next(r)([ts, state]);
+            const set = parse(v);
+            if (typeof set === 'function') {
+                const [[s, r], delta, state0] = measure(() => tryCatch(set))(state);
+                state = state0;
+                if (s !== 'ok') {
+                    ts = addFail(delta)(ts);
+                    if (isGitHub) {
+                        // https://docs.github.com/en/actions/learn-github-actions/workflow-commands-for-github-actions
+                        // https://github.com/OndraM/ci-detector/blob/main/src/Ci/GitHubActions.php
+                        error(`::error file=${k},line=1,title=[3]['a']()::${r}`);
                     }
-                    break;
-                }
-                case 'object': {
-                    if (v !== null) {
-                        const f = ([k, v]) => ([time, state]) => {
-                            log(`${i}${k}:`);
-                            [time, state] = next(v)([time, state]);
-                            return [time, state];
-                        };
-                        [ts, state] = fold(f)([ts, state])(v instanceof Array ? entries(v) : Object.entries(v));
+                    else {
+                        error(`${i}() ${fgRed}error${reset}, ${timeFormat(delta)}`);
+                        error(`${fgRed}${r}${reset}`);
                     }
-                    break;
                 }
+                else {
+                    ts = addPass(delta)(ts);
+                    log(`${i}() ${fgGreen}ok${reset}, ${timeFormat(delta)}`);
+                    [ts, state] = next(r)([ts, state]);
+                }
+            }
+            else {
+                const f = ([k, v]) => ([time, state]) => {
+                    log(`${i}${k}:`);
+                    [time, state] = next(v)([time, state]);
+                    return [time, state];
+                };
+                [ts, state] = fold(f)([ts, state])(set);
             }
             return [ts, state];
         };

package/dev/tf/test.f.d.ts

@@ -0,0 +1,4 @@
+declare const _default: {
+    throw: () => never;
+};
+export default _default;

package/dev/tf/test.f.js

@@ -0,0 +1,5 @@
+export default {
+    throw: () => {
+        throw [() => { }, () => { }];
+    }
+};

package/fsc/test.f.d.ts

@@ -1,4 +1,9 @@
 declare const _default: {
     a: () => void;
+    fn: () => void;
+    f1: () => void;
+    f2: () => void;
+    f3: () => void;
+    f4: () => void;
 };
 export default _default;

package/fsc/test.f.js

@@ -8,11 +8,75 @@ const f = v => {
     const n = one(v);
     return s(_.init(n)[0]);
 };
+// this doesn't change a name of the function
+const fn = (f, name) => ({ [name]: f }[name]);
+const withName = (name) => 
+// translated into one command: define a `function [name]() { return undefined }`
+Object.getOwnPropertyDescriptor({ [name]: () => undefined }, name).value;
 export default {
     a: () => {
         const x = f('1');
-        if (x != '["1"]') {
+        if (x !== '["1"]') {
             throw x;
         }
+    },
+    fn: () => {
+        const o = {
+            ["hello world!"]: () => undefined
+        };
+        const f = o["hello world!"];
+        const { name } = f;
+        if (name !== "hello world!") {
+            throw name;
+        }
+        //
+        const f1 = { ["boring"]: () => undefined }["boring"];
+        if (f1.name !== "boring") {
+            throw f1.name;
+        }
+        //
+        const x = fn(() => undefined, "hello").name;
+        if (x !== "") {
+            throw x;
+        }
+        //
+        const m = withName("boring2").name;
+        if (m !== "boring2") {
+            throw m;
+        }
+        //
+        const a = function x() { return undefined; };
+        if (a.name !== "x") {
+            throw a.name;
+        }
+    },
+    //
+    f1: () => {
+        const m1 = () => undefined;
+        if (m1.name !== "m1") {
+            throw m1.name;
+        }
+    },
+    //
+    f2: () => {
+        const m11 = (() => undefined);
+        if (m11.name !== "m11") {
+            throw m11.name;
+        }
+    },
+    //
+    f3: () => {
+        const m2 = true ? () => undefined : () => undefined;
+        // for `bun` it is `m2`:
+        // if (m2.name !== "") { throw m2.name }
+        // see also https://github.com/oven-sh/bun/issues/20398
+    },
+    f4: () => {
+        const id = (i) => i;
+        const f = id(() => undefined);
+        // for `bun` it is `m2`:
+        if (f.name !== "") {
+            throw f.name;
+        }
     }
 };

package/io/module.f.d.ts

@@ -77,6 +77,7 @@ export type Process = {
     readonly stdout: Writable;
     readonly stderr: Writable;
 };
+export type TryCatch = <T>(f: () => T) => Result<T, unknown>;
 /**
  * Core IO operations interface providing access to system resources
  */
@@ -87,7 +88,7 @@ export type Io = {
     readonly asyncImport: (s: string) => Promise<Module>;
     readonly performance: Performance;
     readonly fetch: (url: string) => Promise<Response>;
-    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
+    readonly tryCatch: TryCatch;
     readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
 };
 /**

package/issues/test.f.d.ts

@@ -1,7 +1,12 @@
 declare const _default: {
     literal: () => void;
     ownProperty: {
-        nullish: () => void;
+        null: {
+            throw: () => PropertyDescriptor | undefined;
+        };
+        undefined: {
+            throw: () => PropertyDescriptor | undefined;
+        };
         bool: () => void;
         array: () => void;
         object: {

package/issues/test.f.js

@@ -6,19 +6,11 @@ export default {
         const m = '<html>Hello</html>';
     },
     ownProperty: {
-        nullish: () => {
-            /* // panic
-            const v = Object.getOwnPropertyDescriptor(null, 0)
-            if (v !== undefined) {
-                throw v
-            }
-            */
-            /* // panic
-            const v = Object.getOwnPropertyDescriptor(undefined, 0)
-            if (v !== undefined) {
-                throw v
-            }
-            */
+        null: {
+            throw: () => Object.getOwnPropertyDescriptor(null, 0),
+        },
+        undefined: {
+            throw: () => Object.getOwnPropertyDescriptor(undefined, 0),
         },
         bool: () => {
             const v = at(true)('x');

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

@@ -0,0 +1,25 @@
+declare const _default: {
+    stringCoercion: {
+        number: () => void;
+        bool: () => void;
+        null: () => void;
+        undefined: () => void;
+        bigint: () => void;
+        array: () => void;
+        func: () => void;
+        object: {
+            norm: () => void;
+            toString: () => void;
+            toStringThrow: {
+                throw: () => void;
+            };
+            toStringNotFunc: {
+                throw: () => void;
+            };
+            toStringNonPrimitive: {
+                throw: () => void;
+            };
+        };
+    };
+};
+export default _default;

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

@@ -0,0 +1,105 @@
+const stringCoercion = (a) => a + '';
+export default {
+    stringCoercion: {
+        number: () => {
+            if (stringCoercion(123) !== '123') {
+                throw [123, 'toString', '123'];
+            }
+            if (stringCoercion(-456) !== '-456') {
+                throw [-456, 'toString', '-456'];
+            }
+            if (stringCoercion(0) !== '0') {
+                throw [0, 'toString', '0'];
+            }
+            if (stringCoercion(-0) !== '0') {
+                throw [0, 'toString', '0'];
+            }
+            if (stringCoercion(1 / (-0)) !== '-Infinity') {
+                throw [0, 'toString', '-Infinity'];
+            }
+            if (stringCoercion(Infinity) !== 'Infinity') {
+                throw [Infinity, 'toString', 'Infinity'];
+            }
+            if (stringCoercion(-Infinity) !== '-Infinity') {
+                throw [-Infinity, 'toString', '-Infinity'];
+            }
+            if (stringCoercion(1 / -Infinity) !== '0') {
+                throw [-Infinity, 'toString', '0'];
+            }
+            if (stringCoercion(NaN) !== 'NaN') {
+                throw [NaN, 'toString', 'NaN'];
+            }
+        },
+        bool: () => {
+            if (stringCoercion(true) !== 'true') {
+                throw [true, 'toString', 'true'];
+            }
+            if (stringCoercion(false) !== 'false') {
+                throw [false, 'toString', 'false'];
+            }
+        },
+        null: () => {
+            if (stringCoercion(null) !== 'null') {
+                throw [null, 'toString', 'null'];
+            }
+        },
+        undefined: () => {
+            if (stringCoercion(undefined) !== 'undefined') {
+                throw [undefined, 'toString', 'undefined'];
+            }
+        },
+        bigint: () => {
+            if (stringCoercion(123n) !== '123') {
+                throw [123n, 'toString', '123'];
+            }
+            if (stringCoercion(-456n) !== '-456') {
+                throw [-456n, 'toString', '-456'];
+            }
+        },
+        array: () => {
+            const arr = [1, 2, 3];
+            if (stringCoercion(arr) !== '1,2,3') {
+                throw [arr, 'toString', '1,2,3'];
+            }
+        },
+        func: () => {
+            const func = () => 5;
+            if (typeof stringCoercion(func) !== 'string') {
+                throw [func, 'toString'];
+            }
+            // if (stringCoercion(func) !== '() => 5') { throw [func, 'toString', 'function result'] }
+        },
+        object: {
+            norm: () => {
+                const obj = { a: 1, b: 2 };
+                if (stringCoercion(obj) !== '[object Object]') {
+                    throw [obj, 'toString', '[object Object]'];
+                }
+            },
+            toString: () => {
+                const x = { toString: () => 'custom string' };
+                if (stringCoercion(x) !== 'custom string') {
+                    throw [x, 'toString', 'custom string'];
+                }
+            },
+            toStringThrow: {
+                throw: () => {
+                    const x = { toString: () => { throw new Error('Custom error'); } };
+                    stringCoercion(x);
+                }
+            },
+            toStringNotFunc: {
+                throw: () => {
+                    const x = { toString: 'hello' };
+                    stringCoercion(x);
+                }
+            },
+            toStringNonPrimitive: {
+                throw: () => {
+                    const x = { toString: () => [] };
+                    stringCoercion(x);
+                }
+            }
+        }
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.6.11",
+  "version": "0.8.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -10,11 +10,12 @@
   "scripts": {
     "prepack": "tsc --NoEmit false",
     "git-clean": "git clean -xf",
-    "test20": "npm run prepack && node ./dev/test/module.js",
-    "test22": "tsc && node --experimental-strip-types ./dev/test/module.ts",
-    "test": "tsc && node ./dev/test/module.ts",
+    "test20": "npm run prepack && node --test",
+    "test22": "tsc && node --test --experimental-strip-types",
+    "test": "tsc && node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "index": "node ./dev/index/module.ts",
     "fsc": "node ./fsc/module.ts",
+    "fst": "node ./dev/tf/module.ts",
     "update": "npm run index && npm install"
   },
   "engines": {
@@ -22,14 +23,14 @@
   },
   "bin": {
     "fsc": "fsc/module.js",
-    "fst": "dev/test/module.js"
+    "fst": "dev/tf/module.js"
   },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/functionalscript/functionalscript.git"
   },
   "author": "Sergey Shandar",
-  "license": "AGPL-3.0-only",
+  "license": "MIT",
   "keywords": [
     "lambda",
     "functional-programming",
@@ -44,8 +45,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^24.0.15",
-    "@typescript/native-preview": "^7.0.0-dev.20250719.1",
-    "typescript": "^5.8.3"
+    "@types/node": "*",
+    "@typescript/native-preview": "*",
+    "typescript": "*"
   }
 }

package/text/module.f.d.ts

@@ -5,7 +5,6 @@ type ItemArray = readonly Item[];
 type ItemThunk = () => List<Item>;
 export type Item = string | ItemArray | ItemThunk;
 export declare const flat: (indent: string) => (text: Block) => List<string>;
-export declare const curly: (type: string) => (name: string) => (body: Block) => Block;
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *

package/text/module.f.js

@@ -1,6 +1,6 @@
 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 { fromCodePointList, toCodePointList } from "./utf8/module.f.js";
 import { stringToCodePointList, codePointListToString } from "./utf16/module.f.js";
 export const flat = (indent) => {
     const f = (prefix) => {
@@ -9,18 +9,18 @@ export const flat = (indent) => {
     };
     return f('');
 };
-export const curly = (type) => (name) => (body) => [`${type} ${name}`, '{', body, '}'];
+const u8ListToVecMsb = u8ListToVec(msb);
 /**
  * Converts a string to an UTF-8, represented as an MSB first bit vector.
  *
  * @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(stringToCodePointList(s)));
+export const msbUtf8 = (s) => u8ListToVecMsb(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) => codePointListToString(utf8.toCodePointList(u8List(msb)(msbV)));
+export const msbUtf8ToString = (msbV) => codePointListToString(toCodePointList(u8List(msb)(msbV)));