functionalscript 0.43.1 → 0.44.0

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

@@ -1,330 +0,0 @@
-import { assert } from '../../fjs/asserts/module.f.js';
-const { is } = Object;
-const ois = (a) => (b) => {
-    assert(is(a, b), [a, 'is', b]);
-};
-const { isNaN } = Number;
-const nanRes = (op) => (n) => {
-    const result = op(n);
-    assert(isNaN(result), result);
-};
-const stringCoercion = String;
-const multiply = (a) => (b) => a * b;
-const multiplyEq = (a) => (b) => (expected) => {
-    ois(multiply(a)(b))(expected);
-    ois(multiply(b)(a))(expected);
-};
-export const proof = {
-    eq: () => {
-        const e = (a) => (b) => {
-            if (a === b) { }
-            else {
-                throw [a, '===', b];
-            }
-        };
-        const n = (a) => (b) => {
-            if (a !== b) { }
-            else {
-                throw [a, '!==', b];
-            }
-        };
-        return {
-            nullish: () => {
-                e(null)(null);
-                e(undefined)(undefined);
-                n(null)(undefined);
-            },
-            boolean: {
-                boolean: () => {
-                    e(true)(true);
-                    e(false)(false);
-                    n(true)(false);
-                },
-                nullish: () => {
-                    n(false)(undefined);
-                    n(false)(null);
-                }
-            },
-            number: {
-                number: () => {
-                    e(2.3)(2.3);
-                    n(2.3)(-5.4);
-                    n(NaN)(NaN);
-                    e(0)(-0);
-                    if (!is(-0, -0)) {
-                        throw -0;
-                    }
-                    if (is(0, -0)) {
-                        throw -0;
-                    }
-                    e(Infinity)(Infinity);
-                    e(-Infinity)(-Infinity);
-                    n(Infinity)(-Infinity);
-                },
-                nullish: () => {
-                    n(undefined)(NaN);
-                    n(undefined)(0);
-                }
-            },
-            string: {
-                string: () => {
-                    e("hello")("hello");
-                    n("hello")("world");
-                },
-                number: () => {
-                    n(0)("0");
-                }
-            },
-            bigint: {
-                bigint: () => {
-                    e(12n)(12n);
-                    n(12n)(-12n);
-                    n(12n)(13n);
-                }
-            },
-            array: {
-                array: () => {
-                    const a = [];
-                    e(a)(a);
-                    n([])([]);
-                    const a0 = ['0'];
-                    e(a0)(a0);
-                }
-            },
-            object: {
-                object: () => {
-                    const o = { '0': '0' };
-                    e(o)(o);
-                    n(o)({ '0': '0' });
-                }
-            }
-        };
-    },
-    unary_plus: () => {
-        const op = (n) => +n;
-        const nan = nanRes(op);
-        return {
-            null: () => ois(op(null))(0),
-            undefined: () => nan(undefined),
-            boolean: {
-                false: () => ois(op(false))(0),
-                true: () => ois(op(true))(1)
-            },
-            number: {
-                zero: () => ois(op(0))(0),
-                positive: () => ois(op(2.3))(2.3),
-                negative: () => ois(op(-2.3))(-2.3)
-            },
-            string: {
-                empty: () => ois(op(""))(0),
-                zero: () => ois(op("0"))(0),
-                positive: () => ois(op("2.3"))(2.3),
-                nan: () => nan("a")
-            },
-            bigint: {
-                throw: () => op(0n),
-            },
-            array: {
-                empty: () => ois(op([]))(0),
-                single_number: () => ois(op([2.3]))(2.3),
-                single_string: () => ois(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(() => { }))
-        };
-    },
-    unary_minus: () => {
-        const op = (n) => -n;
-        const nan = nanRes(op);
-        return {
-            null: () => ois(op(null))(-0),
-            undefined: () => nan(undefined),
-            boolean: {
-                false: () => ois(op(false))(-0),
-                true: () => ois(op(true))(-1)
-            },
-            number: {
-                zero: () => ois(op(0))(-0),
-                positive: () => ois(op(2.3))(-2.3),
-                negative: () => ois(op(-2.3))(2.3)
-            },
-            string: {
-                empty: () => ois(op(""))(-0),
-                zero: () => ois(op("0"))(-0),
-                positive: () => ois(op("2.3"))(-2.3),
-                nan: () => nan("a")
-            },
-            bigint: {
-                positive: () => ois(op(1n))(-1n),
-                negative: () => ois(op(-1n))(1n),
-            },
-            array: {
-                empty: () => ois(op([]))(-0),
-                single_number: () => ois(op([2.3]))(-2.3),
-                single_string: () => ois(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(() => { }))
-        };
-    },
-    mul: () => {
-        return {
-            nullish: () => {
-                multiplyEq(null)(null)(0);
-                multiplyEq(null)(0)(0);
-                multiplyEq(undefined)(0)(NaN);
-            },
-            boolean: () => {
-                multiplyEq(true)(0)(0);
-                multiplyEq(true)(1)(1);
-                multiplyEq(true)(10)(10);
-                multiplyEq(false)(0)(0);
-                multiplyEq(false)(1)(0);
-                multiplyEq(false)(10)(0);
-            },
-            number: () => {
-                multiplyEq(0)(0)(0);
-                multiplyEq(0)(1)(0);
-                multiplyEq(1)(1)(1);
-                multiplyEq(1)(-1)(-1);
-                multiplyEq(1)(10)(10);
-                multiplyEq(-1)(10)(-10);
-                multiplyEq(10)(10)(100);
-                multiplyEq(-10)(10)(-100);
-            },
-            bigint: () => {
-                multiplyEq(0n)(0n)(0n);
-                multiplyEq(0n)(1n)(0n);
-                multiplyEq(1n)(1n)(1n);
-                multiplyEq(1n)(-1n)(-1n);
-                multiplyEq(1n)(10n)(10n);
-                multiplyEq(-1n)(10n)(-10n);
-                multiplyEq(10n)(10n)(100n);
-                multiplyEq(-10n)(10n)(-100n);
-            },
-            string: () => {
-                multiplyEq('')(1)(0);
-                multiplyEq('10')(1)(10);
-                multiplyEq('a')(1)(NaN);
-                multiplyEq('1n')(1)(NaN);
-            },
-            array: () => {
-                multiplyEq([])(1)(0);
-                multiplyEq([10])(1)(10);
-                multiplyEq(['10'])(1)(10);
-                multiplyEq([0, 0])(1)(NaN);
-            },
-            object: () => multiplyEq({})(1)(NaN)
-        };
-    },
-    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/todo/031-json.f.js

@@ -1,241 +0,0 @@
-// 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;
-}
-export {};

package/todo/proof.f.d.ts

@@ -1,20 +0,0 @@
-export declare const proof: {
-    literal: () => void;
-    ownProperty: {
-        null: {
-            throw: () => PropertyDescriptor | undefined;
-        };
-        undefined: {
-            throw: () => PropertyDescriptor | undefined;
-        };
-        bool: () => void;
-        array: () => void;
-        object: {
-            null: () => void;
-            undefined: () => void;
-        };
-        string: {
-            number: () => void;
-        };
-    };
-};

package/todo/proof.f.js

@@ -1,62 +0,0 @@
-const at = a => i => Object.getOwnPropertyDescriptor(a, i)?.value;
-const utf8 = (...x) => x;
-export const proof = {
-    literal: () => {
-        const x = utf8 `17`;
-        const m = '<html>Hello</html>';
-    },
-    ownProperty: {
-        null: {
-            throw: () => Object.getOwnPropertyDescriptor(null, 0),
-        },
-        undefined: {
-            throw: () => Object.getOwnPropertyDescriptor(undefined, 0),
-        },
-        bool: () => {
-            const v = at(true)('x');
-            if (v !== undefined) {
-                throw v;
-            }
-        },
-        array: () => {
-            const a = ['42'];
-            {
-                const v = at(a)('0');
-                if (v !== '42') {
-                    throw v;
-                }
-            }
-            {
-                const v = at(a)(0);
-                if (v !== '42') {
-                    throw v;
-                }
-            }
-        },
-        object: {
-            null: () => {
-                const o = { null: 'hello' };
-                const v = at(o)(null);
-                if (v !== 'hello') {
-                    throw v;
-                }
-            },
-            undefined: () => {
-                const o = { undefined: 'hello' };
-                const v = at(o)(undefined);
-                if (v !== 'hello') {
-                    throw v;
-                }
-            }
-        },
-        string: {
-            number: () => {
-                const o = 'hello';
-                const v = at(o)(1);
-                if (v !== 'e') {
-                    throw v;
-                }
-            }
-        }
-    }
-};