functionalscript 0.7.0 → 0.8.0

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/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/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.7.0",
+  "version": "0.8.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -12,7 +12,7 @@
     "git-clean": "git clean -xf",
     "test20": "npm run prepack && node --test",
     "test22": "tsc && node --test --experimental-strip-types",
-    "test": "tsc && node --test",
+    "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",
@@ -30,7 +30,7 @@
     "url": "git+https://github.com/functionalscript/functionalscript.git"
   },
   "author": "Sergey Shandar",
-  "license": "AGPL-3.0-only",
+  "license": "MIT",
   "keywords": [
     "lambda",
     "functional-programming",
@@ -45,8 +45,8 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^24.2.0",
-    "@typescript/native-preview": "^7.0.0-dev.20250805.1",
-    "typescript": "^5.9.2"
+    "@types/node": "*",
+    "@typescript/native-preview": "*",
+    "typescript": "*"
   }
 }

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;