functionalscript 0.7.0 → 0.8.1

package/json/serializer/test.f.js

@@ -1,22 +1,22 @@
-import * as _ from "./module.f.js";
+import { arrayWrap, boolSerialize, numberSerialize, objectWrap, stringSerialize } from "./module.f.js";
 import * as list from "../../types/list/module.f.js";
 const { toArray } = list;
 export default {
     arrayWrap: [
         () => {
-            const result = JSON.stringify(toArray(_.arrayWrap(null)));
+            const result = JSON.stringify(toArray(arrayWrap(null)));
             if (result !== '["[","]"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.arrayWrap([['a', 'b']])));
+            const result = JSON.stringify(toArray(arrayWrap([['a', 'b']])));
             if (result !== '["[","a","b","]"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.arrayWrap([['a'], ['b']])));
+            const result = JSON.stringify(toArray(arrayWrap([['a'], ['b']])));
             if (result !== '["[","a",",","b","]"]') {
                 throw result;
             }
@@ -24,19 +24,19 @@ export default {
     ],
     objectWrap: [
         () => {
-            const result = JSON.stringify(toArray(_.objectWrap(null)));
+            const result = JSON.stringify(toArray(objectWrap(null)));
             if (result !== '["{","}"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.objectWrap([['a', 'b']])));
+            const result = JSON.stringify(toArray(objectWrap([['a', 'b']])));
             if (result !== '["{","a","b","}"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.objectWrap([['a'], ['b']])));
+            const result = JSON.stringify(toArray(objectWrap([['a'], ['b']])));
             if (result !== '["{","a",",","b","}"]') {
                 throw result;
             }
@@ -44,13 +44,13 @@ export default {
     ],
     stringSerialize: [
         () => {
-            const result = JSON.stringify(toArray(_.stringSerialize('abc')));
+            const result = JSON.stringify(toArray(stringSerialize('abc')));
             if (result !== '["\\"abc\\""]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.stringSerialize('123')));
+            const result = JSON.stringify(toArray(stringSerialize('123')));
             if (result !== '["\\"123\\""]') {
                 throw result;
             }
@@ -58,13 +58,13 @@ export default {
     ],
     numberSerialize: [
         () => {
-            const result = JSON.stringify(toArray(_.numberSerialize(123)));
+            const result = JSON.stringify(toArray(numberSerialize(123)));
             if (result !== '["123"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.numberSerialize(10e20)));
+            const result = JSON.stringify(toArray(numberSerialize(10e20)));
             if (result !== '["1e+21"]') {
                 throw result;
             }
@@ -72,13 +72,13 @@ export default {
     ],
     boolSerialize: [
         () => {
-            const result = JSON.stringify(toArray(_.boolSerialize(false)));
+            const result = JSON.stringify(toArray(boolSerialize(false)));
             if (result !== '["false"]') {
                 throw result;
             }
         },
         () => {
-            const result = JSON.stringify(toArray(_.boolSerialize(true)));
+            const result = JSON.stringify(toArray(boolSerialize(true)));
             if (result !== '["true"]') {
                 throw result;
             }

package/json/test.f.js

@@ -1,25 +1,23 @@
-import * as json from "./module.f.js";
-import * as o from "../types/object/module.f.js";
-const { sort } = o;
-import * as f from "../types/function/module.f.js";
-const { identity } = f;
+import { setProperty, stringify } from "./module.f.js";
+import { sort } from "../types/object/module.f.js";
+import { identity } from "../types/function/module.f.js";
 export default {
     setProperty: () => {
-        if (json.setProperty("Hello")([])({}) !== "Hello") {
+        if (setProperty("Hello")([])({}) !== "Hello") {
             throw 'error';
         }
     },
     stringify: [
         {
             sort: () => {
-                const r = json.setProperty("Hello")(['a'])({});
-                const x = json.stringify(sort)(r);
+                const r = setProperty("Hello")(['a'])({});
+                const x = stringify(sort)(r);
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({}));
+                const x = stringify(identity)(setProperty("Hello")(['a'])({}));
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
@@ -27,13 +25,13 @@ export default {
         },
         {
             sort: () => {
-                const x = json.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringify(sort)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"a":"Hello","b":12,"c":[]}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = json.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringify(identity)(setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"c":[],"b":12,"a":"Hello"}') {
                     throw x;
                 }
@@ -42,16 +40,16 @@ export default {
         {
             sort: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = json.stringify(sort)(_1);
+                const _1 = setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = stringify(sort)(_1);
                 if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
                     throw _2;
                 }
             },
             identity: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
-                const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = json.stringify(identity)(_1);
+                const _1 = setProperty("Hello")(['a', 'x'])(_0);
+                const _2 = stringify(identity)(_1);
                 if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
                     throw _2;
                 }

package/json/tokenizer/module.f.d.ts

@@ -1,8 +1,8 @@
-import * as list from '../../types/list/module.f.ts';
-import * as jsTokenizer from '../../js/tokenizer/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
+import { type EofToken, type ErrorToken, type NumberToken, type StringToken } from '../../js/tokenizer/module.f.ts';
 export type JsonToken = {
     readonly kind: 'true' | 'false' | 'null';
 } | {
     readonly kind: '{' | '}' | ':' | ',' | '[' | ']';
-} | jsTokenizer.StringToken | jsTokenizer.NumberToken | jsTokenizer.ErrorToken | jsTokenizer.EofToken;
-export declare const tokenize: (input: list.List<number>) => list.List<JsonToken>;
+} | StringToken | NumberToken | ErrorToken | EofToken;
+export declare const tokenize: (input: List<number>) => List<JsonToken>;

package/json/tokenizer/module.f.js

@@ -1,8 +1,7 @@
-import * as list from "../../types/list/module.f.js";
-const { empty, flat, stateScan } = list;
-import * as bf from "../../types/bigfloat/module.f.js";
-const { multiply } = bf;
-import * as jsTokenizer from "../../js/tokenizer/module.f.js";
+import {} from "../../types/function/operator/module.f.js";
+import { concat, empty, flat, stateScan } from "../../types/list/module.f.js";
+import { multiply } from "../../types/bigfloat/module.f.js";
+import { tokenize as jsTokenize } from "../../js/tokenizer/module.f.js";
 const mapToken = input => {
     switch (input.kind) {
         case '{':
@@ -47,6 +46,6 @@ const scanToken = state => input => {
     }
 };
 export const tokenize = (input) => {
-    const jsTokens = jsTokenizer.tokenize(input)('');
-    return flat(stateScan(scanToken)({ kind: 'def' })(list.concat(jsTokens)([null])));
+    const jsTokens = jsTokenize(input)('');
+    return flat(stateScan(scanToken)({ kind: 'def' })(concat(jsTokens)([null])));
 };

package/json/tokenizer/test.f.js

@@ -1,12 +1,10 @@
-import * as tokenizer from "./module.f.js";
-import * as list from "../../types/list/module.f.js";
-const { toArray } = list;
-import * as serializer from "../../djs/serializer/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
-import * as encoding from "../../text/utf16/module.f.js";
-const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = serializer.stringifyAsTree(sort);
+import { tokenize } from "./module.f.js";
+import { toArray } from "../../types/list/module.f.js";
+import { stringifyAsTree } from "../../djs/serializer/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { stringToList } from "../../text/utf16/module.f.js";
+const tokenizeString = s => toArray(tokenize(stringToList(s)));
+const stringify = stringifyAsTree(sort);
 export default {
     json: [
         () => {

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.1",
   "type": "module",
   "files": [
     "**/*.js",
@@ -11,12 +11,12 @@
     "prepack": "tsc --NoEmit false",
     "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-strip-types --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"
+    "ci-update": "node ./ci/module.ts",
+    "update": "npm install && npm run index && npm run ci-update"
   },
   "engines": {
     "node": ">=20"
@@ -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"
+    "@playwright/test": "*",
+    "@types/node": "*",
+    "typescript": "*"
   }
 }

package/text/ascii/test.f.js

@@ -1,7 +1,7 @@
 import { range } from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
-const stringify = json.stringify(sort);
+const stringify = jsonStringify(sort);
 export default {
     range: () => {
         const r = stringify(range("A"));

package/text/module.f.d.ts

@@ -5,18 +5,19 @@ 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 type Utf8 = Vec;
 /**
  * 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 declare const msbUtf8: (s: string) => Vec;
+export declare const utf8: (s: string) => Utf8;
 /**
  * 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 declare const msbUtf8ToString: (msbV: Vec) => string;
+export declare const utf8ToString: (msbV: Utf8) => string;
 export {};

package/text/module.f.js

@@ -16,11 +16,11 @@ const u8ListToVecMsb = u8ListToVec(msb);
  * @param s The input string to be converted.
  * @returns The resulting UTF-8 bit vector, MSB first.
  */
-export const msbUtf8 = (s) => u8ListToVecMsb(fromCodePointList(stringToCodePointList(s)));
+export const utf8 = (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(toCodePointList(u8List(msb)(msbV)));
+export const utf8ToString = (msbV) => codePointListToString(toCodePointList(u8List(msb)(msbV)));

package/text/test.f.js

@@ -1,4 +1,4 @@
-import { flat, msbUtf8, msbUtf8ToString } from "./module.f.js";
+import { flat, utf8, utf8ToString } from "./module.f.js";
 import { join } from "../types/string/module.f.js";
 export default {
     block: () => {
@@ -17,8 +17,8 @@ export default {
         }
     },
     encoding: () => {
-        const v = msbUtf8('Hello world!');
-        const r = msbUtf8ToString(v);
+        const v = utf8('Hello world!');
+        const r = utf8ToString(v);
         if (r !== 'Hello world!') {
             throw r;
         }

package/text/utf16/test.f.js

@@ -1,8 +1,8 @@
 import { toCodePointList, fromCodePointList, stringToList, listToString, stringToCodePointList, codePointListToString } from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
-const stringify = (a) => json.stringify(sort)(a);
+const stringify = (a) => jsonStringify(sort)(a);
 export default {
     toCodePointList: [
         () => {

package/text/utf8/test.f.js

@@ -1,8 +1,8 @@
 import { toCodePointList, fromCodePointList } from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
-const stringify = json.stringify(sort);
+const stringify = jsonStringify(sort);
 export default {
     toCodePoint: [
         () => {

package/types/array/test.f.js

@@ -1,7 +1,7 @@
 import { at, first, last, head, tail, splitFirst, splitLast, empty } from "./module.f.js";
-import * as json from "../../json/module.f.js";
+import { stringify as jsonStringify } from "../../json/module.f.js";
 import { sort } from "../object/module.f.js";
-const stringify = json.stringify(sort);
+const stringify = jsonStringify(sort);
 export default {
     stringify: () => {
         const result = stringify([1, 20, 300]);

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

@@ -18,16 +18,16 @@
  * ```
  */
 import { type Sign } from '../function/compare/module.f.ts';
-import type * as Operator from '../function/operator/module.f.ts';
+import type { Unary as OpUnary, Reduce as OpReduce } from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
 /**
  * Type representing a unary operation on `bigint`.
  */
-export type Unary = Operator.Unary<bigint, bigint>;
+export type Unary = OpUnary<bigint, bigint>;
 /**
  * Type representing a reduction operation on `bigint` values.
  */
-export type Reduce = Operator.Reduce<bigint>;
+export type Reduce = OpReduce<bigint>;
 /**
  * Adds two `bigint` values.
  *
@@ -165,3 +165,6 @@ export declare const factorial: (b: bigint) => bigint;
  * @returns The number of combinations.
  */
 export declare const combination: (...k: readonly bigint[]) => bigint;
+export declare const xor: Reduce;
+export declare const divUp: Reduce;
+export declare const roundUp: Reduce;

package/types/bigint/module.f.js

@@ -17,7 +17,7 @@
  * const c = combination([3n, 2n, 1n]) // 60n
  * ```
  */
-import { unsafeCmp } from "../function/compare/module.f.js";
+import { cmp } from "../function/compare/module.f.js";
 import { reduce } from "../list/module.f.js";
 /**
  * Adds two `bigint` values.
@@ -59,7 +59,7 @@ export const abs = a => a >= 0 ? a : -a;
  * @param a - The bigint value.
  * @returns `1` if positive, `-1` if negative, and `0` if zero.
  */
-export const sign = (a) => unsafeCmp(a)(0n);
+export const sign = (a) => cmp(a)(0n);
 /**
  * Serializes a `bigint` to a string representation.
  *
@@ -160,15 +160,7 @@ export const log2 = (v) => {
  * The function uses the `log2` function to calculate the position of the most significant bit (MSB)
  * and adds `1n` to account for the MSB itself. For negative numbers, the absolute value is used.
  */
-export const bitLength = (v) => {
-    if (v <= 0n) {
-        if (v === 0n) {
-            return 0n;
-        }
-        v = -v;
-    }
-    return log2(v) + 1n;
-};
+export const bitLength = (v) => log2(abs(v)) + 1n;
 /**
  * Generates a bitmask with the specified number of bits set to 1.
  *
@@ -238,3 +230,12 @@ export const combination = (...k) => {
     }
     return partialFactorial(m)(s) / p;
 };
+export const xor = a => b => a ^ b;
+export const divUp = b => {
+    const m = b - 1n;
+    return v => (v + m) / b;
+};
+export const roundUp = b => {
+    const d = divUp(b);
+    return v => d(v) * b;
+};

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

@@ -27,5 +27,7 @@ declare const _default: {
     combination: () => void;
     combination50x50: () => void;
     combination3: () => void;
+    divUp: () => void;
+    roundUp: () => void;
 };
 export default _default;

package/types/bigint/test.f.js

@@ -1,4 +1,4 @@
-import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial } from "./module.f.js";
+import { sum, abs, serialize, log2, bitLength, mask, min, combination, factorial, divUp, roundUp } from "./module.f.js";
 const oldLog2 = (v) => {
     if (v <= 0n) {
         return -1n;
@@ -451,5 +451,24 @@ export default {
         if (r !== 69300n) {
             throw r;
         }
-    }
+    },
+    divUp: () => {
+        if (divUp(8n)(8n) !== 1n) {
+            throw new Error("fail");
+        }
+        if (divUp(8n)(15n) !== 2n) {
+            throw new Error("fail");
+        }
+    },
+    roundUp: () => {
+        if (roundUp(8n)(8n) !== 8n) {
+            throw new Error("fail");
+        }
+        if (roundUp(8n)(15n) !== 16n) {
+            throw new Error("fail");
+        }
+        if (roundUp(8n)(3n) !== 8n) {
+            throw new Error("fail");
+        }
+    },
 };