functionalscript 0.37.0 → 0.38.0

package/{fs → fjs}/types/list/proof.f.js

@@ -2,190 +2,134 @@ import { length, concat, countdown, cycle, drop, dropWhile, entries, every, filt
 import { stringify } from '../../media/json/module.f.js';
 import { sort } from '../object/module.f.js';
 import { addition, strictEqual, reduceToScan } from '../function/operator/module.f.js';
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
 const str = sequence => stringify(sort)(toArray(sequence));
 const stringifyTest = () => {
     const s = str([1, 2, 3]);
-    if (s !== '[1,2,3]') {
-        throw s;
-    }
+    assertEq(s, '[1,2,3]');
 };
 const cycleTest = [
     () => {
         const x = str(toArray(take(10)(cycle([1, 2, 3]))));
-        if (x !== '[1,2,3,1,2,3,1,2,3,1]') {
-            throw x;
-        }
+        assertEq(x, '[1,2,3,1,2,3,1,2,3,1]');
     },
     () => {
         const x = str(toArray(cycle([])));
-        if (x !== '[]') {
-            throw x;
-        }
+        assertEq(x, '[]');
     },
 ];
 const countdownTest = () => {
     const result = str(countdown(10));
-    if (result !== '[9,8,7,6,5,4,3,2,1,0]') {
-        throw result;
-    }
+    assertEq(result, '[9,8,7,6,5,4,3,2,1,0]');
 };
 const flatTest = () => {
     const result = str(flat([[1, 2, 3], [4, 5], [6], [], [7, 8, 9]]));
-    if (result !== '[1,2,3,4,5,6,7,8,9]') {
-        throw result;
-    }
+    assertEq(result, '[1,2,3,4,5,6,7,8,9]');
 };
 const concatTest = () => {
     const result = concat([1])([2]);
-    const x = next(result);
-    if (x === null) {
-        throw x;
-    }
-    if (x.first !== 1) {
-        throw x;
-    }
+    const x = assertNotNullish(next(result));
+    assertEq(x.first, 1, x);
 };
 const flatMapTest = () => {
     const result = str(flatMap((x) => [x, x * 2, x * 3])([0, 1, 2, 3]));
-    if (result !== '[0,0,0,1,2,3,2,4,6,3,6,9]') {
-        throw result;
-    }
+    assertEq(result, '[0,0,0,1,2,3,2,4,6,3,6,9]');
 };
 const takeTest = [
     () => {
         const result = str(take(3)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        if (result !== '[1,2,3]') {
-            throw result;
-        }
+        assertEq(result, '[1,2,3]');
     },
     () => {
         const result = str(take(20)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        if (result !== '[1,2,3,4,5,6,7,8,9]') {
-            throw result;
-        }
+        assertEq(result, '[1,2,3,4,5,6,7,8,9]');
     },
     () => {
         const result = str(take(0)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        if (result !== '[]') {
-            throw result;
-        }
+        assertEq(result, '[]');
     }
 ];
 const findTest = [
     () => {
         const result = find(null)((x) => x % 2 === 0)([1, 3, 5, 7]);
-        if (result !== null) {
-            throw result;
-        }
+        assertEq(result, null);
     },
     () => {
         const result = find(null)((x) => x % 2 === 0)([1, 2, 3, 4]);
-        if (result !== 2) {
-            throw result;
-        }
+        assertEq(result, 2);
     }
 ];
 const takeWhileTest = [
     () => {
         const result = str(takeWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
-        if (result !== '[1,2,3,4,5]') {
-            throw result;
-        }
+        assertEq(result, '[1,2,3,4,5]');
     },
     () => {
         const result = str(takeWhile((x) => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]));
-        if (result !== '[1,2,3,4,5]') {
-            throw result;
-        }
+        assertEq(result, '[1,2,3,4,5]');
     }
 ];
 const dropWhileTest = () => {
     const result = str(dropWhile((x) => x < 10)([1, 2, 3, 4, 5, 10, 11]));
-    if (result !== '[10,11]') {
-        throw result;
-    }
+    assertEq(result, '[10,11]');
 };
 const dropTest = [
     () => {
         const result = str(drop(3)([1, 2, 3, 4, 5, 10, 11]));
-        if (result !== '[4,5,10,11]') {
-            throw result;
-        }
+        assertEq(result, '[4,5,10,11]');
     },
     () => {
         const result = str(drop(0)([1, 2, 3, 4, 5, 10, 11]));
-        if (result !== '[1,2,3,4,5,10,11]') {
-            throw result;
-        }
+        assertEq(result, '[1,2,3,4,5,10,11]');
     },
     () => {
         const result = str(drop(10)([1, 2, 3, 4, 5, 10, 11]));
-        if (result !== '[]') {
-            throw result;
-        }
+        assertEq(result, '[]');
     }
 ];
 const additionTests = [
     () => {
         const op = reduceToScan(addition);
         const result = str(scan(op)([2, 3, 4, 5]));
-        if (result !== '[2,5,9,14]') {
-            throw result;
-        }
+        assertEq(result, '[2,5,9,14]');
     },
     () => {
         const result = reduce(addition)(null)([2, 3, 4, 5]);
-        if (result !== 14) {
-            throw result;
-        }
+        assertEq(result, 14);
     },
     () => {
         const result = reduce(addition)(null)([]);
-        if (result !== null) {
-            throw result;
-        }
+        assertEq(result, null);
     }
 ];
 const entriesTest = [
     () => {
         const result = str(entries([]));
-        if (result !== '[]') {
-            throw result;
-        }
+        assertEq(result, '[]');
     },
     () => {
         const result = str(entries(['hello', 'world']));
-        if (result !== '[[0,"hello"],[1,"world"]]') {
-            throw result;
-        }
+        assertEq(result, '[[0,"hello"],[1,"world"]]');
     }
 ];
 const reverseTest = [
     () => {
         const result = str(reverse([]));
-        if (result !== '[]') {
-            throw result;
-        }
+        assertEq(result, '[]');
     },
     () => {
         const result = str(reverse([1, 2, 3, 4, 5]));
-        if (result !== '[5,4,3,2,1]') {
-            throw result;
-        }
+        assertEq(result, '[5,4,3,2,1]');
     }
 ];
 const zipTest = [
     () => {
         const result = str(zip([0, 1, 2])(['a', 'b', 'c', 'd']));
-        if (result !== '[[0,"a"],[1,"b"],[2,"c"]]') {
-            throw result;
-        }
+        assertEq(result, '[[0,"a"],[1,"b"],[2,"c"]]');
     },
     () => {
         const result = str(zip([0, 1, 2])(['a', 'b']));
-        if (result !== '[[0,"a"],[1,"b"]]') {
-            throw result;
-        }
+        assertEq(result, '[[0,"a"],[1,"b"]]');
     }
 ];
 const logic = () => {
@@ -193,39 +137,27 @@ const logic = () => {
     return [
         () => {
             const result = some(map5([0, 1, 7]));
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         },
         () => {
             const result = some(map5([0, 1, 4]));
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = some(map5([]));
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = every(map5([0, 1, 7]));
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = every(map5([6, 11, 7]));
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         },
         () => {
             const result = every(map5([]));
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         }
     ];
 };
@@ -235,25 +167,17 @@ const stress = () => ({
         // 200_000_000 is too much
         const n = 100_000_000;
         const result = toArray(countdown(n));
-        if (result.length !== n) {
-            throw result.length;
-        }
+        assertEq(result.length, n);
         const len = length(filter((x) => x > n)(result));
-        if (len !== 0) {
-            throw len;
-        }
+        assertEq(len, 0);
     },
     first: () => {
         // 100_000_000 is too much
         const n = 50_000_000;
         const result = toArray(countdown(n));
-        if (result.length !== n) {
-            throw result.length;
-        }
+        assertEq(result.length, n);
         const f = first(null)(result);
-        if (f !== n - 1) {
-            throw f;
-        }
+        assertEq(f, n - 1);
     },
     concatBack: () => {
         let sequence = [];
@@ -300,33 +224,23 @@ const stress = () => ({
         // 100_000_000 is too much
         const n = 50_000_000;
         const result = toArray(countdown(n));
-        if (result.length !== n) {
-            throw result.length;
-        }
+        assertEq(result.length, n);
         const len = length(filterMap(() => null)(result));
-        if (len !== 0) {
-            throw len;
-        }
+        assertEq(len, 0);
     },
     dropWhile: () => {
         // 50_000_000 is too much
         const n = 20_000_000;
         const result = toArray(countdown(n));
-        if (result.length !== n) {
-            throw result.length;
-        }
+        assertEq(result.length, n);
         const len = length(dropWhile(() => true)(result));
-        if (len !== 0) {
-            throw len;
-        }
+        assertEq(len, 0);
     },
     reverse: () => {
         // 10_000_000 is too much
         const n = 5_000_000;
         const result = toArray(reverse(countdown(n)));
-        if (result.length !== n) {
-            throw result.length;
-        }
+        assertEq(result.length, n);
     }
 });
 export const proof = {
@@ -349,66 +263,44 @@ export const proof = {
     strictEqual: [
         () => {
             const result = equal(strictEqual)([1])([2, 3]);
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = equal(strictEqual)([1, 3])([1]);
-            if (result) {
-                throw result;
-            }
+            assert(!(result), result);
         },
         () => {
             const result = equal(strictEqual)([15, 78])([15, 78]);
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         },
         () => {
             const result = equal(strictEqual)([])([]);
-            if (!result) {
-                throw result;
-            }
+            assert(result, result);
         }
     ],
     isEmpty: [
         () => {
             const result = isEmpty(() => []);
-            if (result !== true) {
-                throw result;
-            }
+            assertEq(result, true);
         },
         () => {
             const result = isEmpty(() => [2]);
-            if (result !== false) {
-                throw result;
-            }
+            assertEq(result, false);
         }
     ],
     length: () => {
-        if (length([1, 2, 3]) !== 3) {
-            throw 3;
-        }
-        if (length(null) !== 0) {
-            throw 0;
-        }
-        if (length(flat([[1, 3], null, () => [3], concat([12])([4, 89])])) !== 6) {
-            throw 6;
-        }
+        assertEq(length([1, 2, 3]), 3);
+        assertEq(length(null), 0);
+        assertEq(length(flat([[1, 3], null, () => [3], concat([12])([4, 89])])), 6);
     },
     filterMap: [
         () => {
             const result = str(filterMap((x) => x % 2 === 0 ? x * 10 : null)([1, 2, 3, 4, 5]));
-            if (result !== '[20,40]') {
-                throw result;
-            }
+            assertEq(result, '[20,40]');
         },
         () => {
             const result = str(filterMap((x) => x > 3 ? x : null)([1, 2, 3]));
-            if (result !== '[]') {
-                throw result;
-            }
+            assertEq(result, '[]');
         },
     ],
     // stress

package/{fs → fjs}/types/map/proof.f.js

@@ -3,21 +3,13 @@ import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     set: () => {
         const map = mapSet(new Map(), 'a', 'b');
-        if (map.get('a') !== 'b') {
-            throw 'error';
-        }
-        if (map.size !== 1) {
-            throw 'error';
-        }
+        assertEq(map.get('a'), 'b', 'error');
+        assertEq(map.size, 1, 'error');
     },
     delete: () => {
         const map = mapDelete(mapSet(new Map(), 'a', 'b'), 'a');
-        if (map.get('a') !== undefined) {
-            throw 'error';
-        }
-        if (map.size !== 0) {
-            throw 'error';
-        }
+        assertEq(map.get('a'), undefined, 'error');
+        assertEq(map.size, 0, 'error');
     },
     deleteOneOfMany: () => {
         const m0 = mapSet(new Map(), 'a', 1);

package/{fs → fjs}/types/nibble_set/proof.f.js

@@ -1,16 +1,11 @@
 import { every, map, countdown } from '../list/module.f.js';
 import { empty, has, set, setRange, unset, universe, complement } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 export const proof = {
     has: () => {
-        if (has(0)(empty)) {
-            throw empty;
-        }
-        if (has(1)(empty)) {
-            throw empty;
-        }
-        if (has(15)(empty)) {
-            throw empty;
-        }
+        assert(!(has(0)(empty)), empty);
+        assert(!(has(1)(empty)), empty);
+        assert(!(has(15)(empty)), empty);
     },
     set: [
         () => {
@@ -21,69 +16,45 @@ export const proof = {
             if (!has(0)(s)) {
                 throw s;
             }
-            if (has(1)(s)) {
-                throw s;
-            }
-            if (has(15)(s)) {
-                throw s;
-            }
+            assert(!(has(1)(s)), s);
+            assert(!(has(15)(s)), s);
         },
         () => {
             const s = set(15)(empty);
-            if (s !== 0x8000) {
-                throw s;
-            }
-            if (has(0)(s)) {
-                throw s;
-            }
-            if (has(1)(s)) {
-                throw s;
-            }
-            if (!has(15)(s)) {
-                throw s;
-            }
+            assertEq(s, 0x8000);
+            assert(!(has(0)(s)), s);
+            assert(!(has(1)(s)), s);
+            assert(has(15)(s), s);
         }
     ],
     unset: () => [
         () => {
             const a = set(0)(empty);
             const result = unset(0)(a);
-            if (result !== 0) {
-                throw result;
-            }
+            assertEq(result, 0);
         },
         () => {
             const a = set(15)(empty);
             const result = unset(15)(a);
-            if (result !== 0) {
-                throw result;
-            }
+            assertEq(result, 0);
         }
     ],
     setRange: () => {
         const result = setRange([2, 5])(empty);
-        if (result !== 60) {
-            throw result;
-        }
+        assertEq(result, 60);
     },
     universe: () => {
         const x = every(map((v) => has(v)(universe))(countdown(16)));
-        if (!x) {
-            throw x;
-        }
+        assert(x, x);
     },
     compliment: {
         empty: () => {
             const r = complement(empty);
-            if (r !== universe) {
-                throw r;
-            }
+            assertEq(r, universe);
         },
         universe: () => {
             const r = complement(universe);
-            if (r !== empty) {
-                throw r;
-            }
+            assertEq(r, empty);
         },
     }
 };

package/{fs → fjs}/types/nominal/proof.f.js

@@ -1,11 +1,10 @@
 import { asBase, asNominal } from "./module.f.js";
+import { assert } from '../../asserts/module.f.js';
 export const proof = {
     pre: () => {
         const strA = asNominal(7560413859n); // "¢£"
         const strB = asNominal(7560413860n); // "¢¤"
-        if (strA === strB) {
-            throw [strA, strB];
-        }
+        assert(strA !== strB, [strA, strB]);
         // // TypeScript compilation error.
         // const x1 = strA > strB
         //
@@ -35,17 +34,13 @@ export const proof = {
     nominal: () => {
         const userIdA = asNominal(123);
         const userIdB = asNominal(456);
-        if (userIdA === userIdB) {
-            throw [userIdA, userIdB];
-        }
+        assert(userIdA !== userIdB, [userIdA, userIdB]);
         const to = asBase;
         const to2 = asBase;
         const userId2A = asNominal(123);
         const userId2B = asNominal(456);
-        if (userId2A === userId2B) {
-            throw [userId2A, userId2B];
-        }
-        // if (userIdA === userId2A) { throw [userIdA, userId2A] } // compilation error
+        assert(userId2A !== userId2B, [userId2A, userId2B]);
+        // assert(userIdA !== userId2A, [userIdA, userId2A]) // compilation error
         const n1 = to(userIdA);
         const n2 = to2(userId2A);
         // const x = to(userId2A) // compilation error

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

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

package/{fs → fjs}/types/number/proof.f.js

@@ -1,42 +1,31 @@
 import { sum, min, max, cmp, countOnes } from './module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 export const proof = {
     sum: () => {
         const result = sum([2, 3, 4, 5]);
-        if (result !== 14) {
-            throw result;
-        }
+        assertEq(result, 14);
     },
     min: {
         empty: () => {
             const result = min([]);
-            if (result !== null) {
-                throw result;
-            }
+            assertEq(result, null);
         },
         multi: () => {
             const result = min([1, 2, 12, -4, 8]);
-            if (result !== -4) {
-                throw result;
-            }
+            assertEq(result, -4);
         }
     },
     max: () => {
         const result = max([1, 2, 12, -4, 8]);
-        if (result !== 12) {
-            throw result;
-        }
+        assertEq(result, 12);
     },
     cmp: () => {
         const result = cmp(4)(5);
-        if (result !== -1) {
-            throw result;
-        }
+        assertEq(result, -1);
     },
     standard: () => {
         const check = a => b => {
-            if (BigInt(Number(a)) !== b) {
-                throw [a, b];
-            }
+            assertEq(BigInt(Number(a)), b, [a, b]);
         };
         const eq = v => check(v)(v);
         // 53, 0x35 bits.
@@ -124,16 +113,12 @@ export const proof = {
         () => {
             //                    1121 2231 = 5 + 8 = 13
             const r = countOnes(0x1234_5678);
-            if (r !== 13) {
-                throw r;
-            }
+            assertEq(r, 13);
         },
         () => {
             //                    2232 3340 = 9 + 10 = 19
             const r = countOnes(0x9ABC_DEF0);
-            if (r !== 19) {
-                throw r;
-            }
+            assertEq(r, 19);
         }
     ]
 };