functionalscript 0.37.0 → 0.39.0

package/fs/types/bigfloat/proof.f.js

@@ -1,348 +0,0 @@
-import { decToBin } from './module.f.js';
-export const proof = {
-    decToBin: [
-        () => {
-            const result = decToBin([0n, 0]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([0n, 10]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([0n, -10]);
-            if (result[0] !== 0n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 0) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, 0]);
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -52) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, 1]);
-            if (result[0] !== 5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1000n, -2]);
-            if (result[0] !== 5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([1n, -1]);
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            } //+1
-            if (result[1] !== -56) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, 0]);
-            if (result[0] !== -4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -52) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, 1]);
-            if (result[0] !== -5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1000n, -2]);
-            if (result[0] !== -5629499534213120n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== -49) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-1n, -1]);
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            } //+1
-            if (result[1] !== -56) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([9007199254740993n, 0]); //54bits (...0.1)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
-            if (result[0] !== -4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740993n, 0]); //54bits (...0.1)
-            if (result[0] !== -4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-9007199254740995n, 0]); //54bits (...1.1)
-            if (result[0] !== -4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 1) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481985n, 0]); //55bits (...0.01)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481986n, 0]); //55bits (...0.10)
-            if (result[0] !== 4503599627370496n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481990n, 0]); //55bits (...1.10)
-            if (result[0] !== 4503599627370498n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([18014398509481987n, 0]); //55bits (0.11)
-            if (result[0] !== 4503599627370497n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-    ],
-    roundingPositive: [
-        () => {
-            const result = decToBin([288230376151711745n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011001.101
-            // rounding up
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711760n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.000
-            // rounding down
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711780n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.100
-            // rounding down (to even)
-            if (result[0] !== 7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711781n, -1]);
-            // reminder = 1
-            // m = 11001100110011001100110011001100110011001100110011010.100
-            // rounding up
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711785n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011010.101
-            // rounding up
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711805n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011011.001
-            // rounding down
-            if (result[0] !== 7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([288230376151711820n, -1]);
-            // reminder = 0
-            // m = 11001100110011001100110011001100110011001100110011011.100
-            // rounding up (to even)
-            if (result[0] !== 7205759403792796n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        }
-    ],
-    roundingNegative: [
-        () => {
-            const result = decToBin([-288230376151711745n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011001.101
-            // rounding down
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711760n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.000
-            // rounding up
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711780n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.100
-            // rounding up (to even)
-            if (result[0] !== -7205759403792794n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711781n, -1]);
-            // reminder = 1
-            // m = -11001100110011001100110011001100110011001100110011010.100
-            // rounding down
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711785n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011010.101
-            // rounding down
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711805n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011011.001
-            // rounding up
-            if (result[0] !== -7205759403792795n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        },
-        () => {
-            const result = decToBin([-288230376151711820n, -1]);
-            // reminder = 0
-            // m = -11001100110011001100110011001100110011001100110011011.100
-            // rounding down (to even)
-            if (result[0] !== -7205759403792796n) {
-                throw result[0].toString(2);
-            }
-            if (result[1] !== 2) {
-                throw result[1];
-            }
-        }
-    ]
-};

package/fs/types/nullable/proof.f.js

@@ -1,50 +0,0 @@
-import { fromUndefined, map, match, toOption } from './module.f.js';
-export const proof = [
-    () => {
-        const optionSq = map((v) => v * v);
-        const sq3 = optionSq(3);
-        if (sq3 !== 9) {
-            throw sq3;
-        }
-        const sqNull = optionSq(null);
-        if (sqNull !== null) {
-            throw sqNull;
-        }
-    },
-    () => {
-        const opt1 = toOption(5);
-        if (opt1.length !== 1 || opt1[0] !== 5) {
-            throw opt1;
-        }
-        const opt2 = toOption(null);
-        if (opt2.length !== 0) {
-            throw opt2;
-        }
-    },
-    () => {
-        const double = match((v) => v * 2)(() => -1);
-        if (double(3) !== 6) {
-            throw double(3);
-        }
-        if (double(null) !== -1) {
-            throw double(null);
-        }
-    },
-    () => {
-        if (fromUndefined(undefined) !== null) {
-            throw 0;
-        }
-        if (fromUndefined(5) !== 5) {
-            throw 1;
-        }
-        if (fromUndefined(0) !== 0) {
-            throw 2;
-        }
-        if (fromUndefined(null) !== null) {
-            throw 3;
-        }
-        if (fromUndefined('') !== '') {
-            throw 4;
-        }
-    },
-];

package/fs/types/range/module.f.js

@@ -1,2 +0,0 @@
-export const contains = ([b, e]) => i => b <= i && i <= e;
-export const one = a => [a, a];

package/fs/types/range/proof.f.js

@@ -1,18 +0,0 @@
-import { contains } from './module.f.js';
-export const proof = () => {
-    if (!contains([0, 5])(1)) {
-        throw 1;
-    }
-    if (!contains([0, 5])(0)) {
-        throw 0;
-    }
-    if (!contains([0, 5])(5)) {
-        throw 5;
-    }
-    if (contains([0, 5])(-1)) {
-        throw -1;
-    }
-    if (contains([0, 5])(6)) {
-        throw 6;
-    }
-};

package/fs/types/result/proof.f.js

@@ -1,52 +0,0 @@
-import { error, ok, unwrap, invert, mapOk } from "./module.f.js";
-const example = () => {
-    const success = ok(42);
-    const failure = error('Something went wrong');
-    if (unwrap(success) !== 42) {
-        throw 'error';
-    }
-    const [kind, v] = failure;
-    if (kind !== 'error') {
-        throw 'error';
-    }
-    // `v` is inferred as `string` here
-    if (v !== 'Something went wrong') {
-        throw 'error';
-    }
-};
-const invertTest = () => {
-    const [k0, v0] = invert(ok(42));
-    if (k0 !== 'error' || v0 !== 42) {
-        throw [k0, v0];
-    }
-    const [k1, v1] = invert(error('oops'));
-    if (k1 !== 'ok' || v1 !== 'oops') {
-        throw [k1, v1];
-    }
-};
-const unwrapError = () => {
-    let caught = false;
-    try {
-        unwrap(error('oops'));
-    }
-    catch (e) {
-        if (e !== 'oops') {
-            throw e;
-        }
-        caught = true;
-    }
-    if (!caught) {
-        throw 'expected throw';
-    }
-};
-const mapOkTest = () => {
-    const [k0, v0] = mapOk((n) => n + 1)(ok(41));
-    if (k0 !== 'ok' || v0 !== 42) {
-        throw [k0, v0];
-    }
-    const [k1, v1] = mapOk((n) => n + 1)(error('oops'));
-    if (k1 !== 'error' || v1 !== 'oops') {
-        throw [k1, v1];
-    }
-};
-export const proof = { example, invertTest, unwrapError, mapOkTest };

package/fs/types/string/proof.f.js

@@ -1,118 +0,0 @@
-import { join, concat, repeat, cmp, splitAt } from './module.f.js';
-import { repeat as repeatList } from '../list/module.f.js';
-export const proof = {
-    example: () => {
-        const words = ['hello', 'world'];
-        if (join(' ')(words) !== 'hello world') {
-            throw 0;
-        }
-        if (concat(words) !== 'helloworld') {
-            throw 1;
-        }
-        if (repeat('abc')(3) !== 'abcabcabc') {
-            throw 2;
-        }
-        if (cmp('apple')('banana') !== -1) {
-            throw 3;
-        }
-    },
-    join: {
-        0: () => {
-            const result = join('/')([]);
-            if (result !== '') {
-                throw result;
-            }
-        },
-        1: () => {
-            const result = join('/')(['']);
-            if (result !== '') {
-                throw result;
-            }
-        },
-        3: () => {
-            const result = join(' ')(['hello', 'world', '!']);
-            if (result !== 'hello world !') {
-                throw result;
-            }
-        }
-    },
-    concat: () => {
-        const result = concat(['hello', 'world']);
-        if (result !== 'helloworld') {
-            throw result;
-        }
-    },
-    repeatList: {
-        0: () => {
-            const s = join('.')(repeatList('x')(0));
-            if (s != '') {
-                throw s;
-            }
-        },
-        5: () => {
-            const s = join('.')(repeatList('x')(5));
-            if (s != 'x.x.x.x.x') {
-                throw s;
-            }
-        }
-    },
-    repeat: () => {
-        const s = repeat('x')(5);
-        if (s != 'xxxxx') {
-            throw s;
-        }
-    },
-    cmp: () => {
-        const result = cmp('3')('4');
-        if (result !== -1) {
-            throw result;
-        }
-    },
-    splitAt: {
-        middle: () => {
-            const [a, b] = splitAt(3)('hello');
-            if (a !== 'hel') {
-                throw a;
-            }
-            if (b !== 'lo') {
-                throw b;
-            }
-        },
-        zero: () => {
-            const [a, b] = splitAt(0)('hello');
-            if (a !== '') {
-                throw a;
-            }
-            if (b !== 'hello') {
-                throw b;
-            }
-        },
-        full: () => {
-            const [a, b] = splitAt(5)('hello');
-            if (a !== 'hello') {
-                throw a;
-            }
-            if (b !== '') {
-                throw b;
-            }
-        },
-        beyond: () => {
-            const [a, b] = splitAt(10)('hello');
-            if (a !== 'hello') {
-                throw a;
-            }
-            if (b !== '') {
-                throw b;
-            }
-        },
-        empty: () => {
-            const [a, b] = splitAt(0)('');
-            if (a !== '') {
-                throw a;
-            }
-            if (b !== '') {
-                throw b;
-            }
-        },
-    }
-};

package/fs/types/string_set/proof.f.js

@@ -1,82 +0,0 @@
-import { contains, fromValues, remove, set } from './module.f.js';
-export const proof = {
-    example: () => {
-        let mySet = fromValues(['apple', 'banana', 'cherry']);
-        if (!contains('banana')(mySet)) {
-            throw '1';
-        }
-        if (contains('date')(mySet)) {
-            throw '2';
-        }
-        mySet = set('date')(mySet);
-        if (!contains('date')(mySet)) {
-            throw '3';
-        }
-        mySet = remove('banana')(mySet);
-        if (contains('banana')(mySet)) {
-            throw '4';
-        }
-    },
-    contains: () => {
-        const r = set('hello')(null);
-        if (!contains('hello')(r)) {
-            throw r;
-        }
-        if (contains('hello1')(r)) {
-            throw r;
-        }
-    },
-    remove: () => {
-        let r = set('hello')(null);
-        r = set('world')(r);
-        r = set('HELLO')(r);
-        r = set('WORLD!')(r);
-        if (!contains('hello')(r)) {
-            throw r;
-        }
-        if (contains('hello1')(r)) {
-            throw r;
-        }
-        if (!contains('HELLO')(r)) {
-            throw r;
-        }
-        if (contains('WORLD')(r)) {
-            throw r;
-        }
-        if (!contains('world')(r)) {
-            throw r;
-        }
-        if (contains('world!')(r)) {
-            throw r;
-        }
-        if (!contains('WORLD!')(r)) {
-            throw r;
-        }
-        //
-        r = remove('hello')(r);
-        if (contains('hello')(r)) {
-            throw r;
-        }
-        if (!contains('world')(r)) {
-            throw r;
-        }
-        r = remove('world')(r);
-        if (contains('world')(r)) {
-            throw r;
-        }
-        if (!contains('HELLO')(r)) {
-            throw r;
-        }
-        r = remove('HELLO')(r);
-        if (contains('HELLO')(r)) {
-            throw r;
-        }
-        if (!contains('WORLD!')(r)) {
-            throw r;
-        }
-        r = remove('WORLD!')(r);
-        if (r !== null) {
-            throw r;
-        }
-    }
-};