functionalscript 0.36.0 → 0.38.0

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

@@ -1,8 +1,8 @@
-import { assertEq } from "../../asserts/module.f.js";
-import { mask } from "../bigint/module.f.js";
-import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from "./module.f.js";
-import { repeat as listRepeat, toArray } from "../list/module.f.js";
+import { assert, assertEq } from '../../asserts/module.f.js';
+import { mask } from '../bigint/module.f.js';
+import { asBase, asNominal } from '../nominal/module.f.js';
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, maxLength, u8ListToVec, tryU8ListToVec, u8List, chunkList, fromSentinel } from './module.f.js';
+import { repeat as listRepeat, toArray } from '../list/module.f.js';
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
 // 0x9 = 0b1001 = 1 + 8
@@ -18,63 +18,37 @@ const assertEq2 = ([a0, a1], [b0, b1]) => {
 };
 const frontTest = (e) => (r0) => (r1) => () => {
     const vector = vec(8n)(0xf5n); // 0xF5n
-    if (vector !== unsafeVec(0xf5n)) {
-        throw vector;
-    }
+    assertEq(vector, unsafeVec(0xf5n));
     const result = e.front(4n)(vector);
-    if (result !== r0) {
-        throw result;
-    }
+    assertEq(result, r0);
     const result2 = e.front(16n)(vector);
-    if (result2 !== r1) {
-        throw result2;
-    }
+    assertEq(result2, r1);
 };
 const popFront = (e) => ([r00, r01]) => ([r10, r11]) => () => {
     const vector = vec(8n)(0xf5n); // 0xF5n
     const [result, rest] = e.popFront(4n)(vector);
-    if (result !== r00) {
-        throw result;
-    }
-    if (rest !== unsafeVec(r01)) {
-        throw rest;
-    }
+    assertEq(result, r00);
+    assertEq(rest, unsafeVec(r01));
     const [result2, rest2] = e.popFront(16n)(vector);
-    if (result2 !== r10) {
-        throw result2;
-    }
-    if (rest2 !== unsafeVec(r11)) {
-        throw rest2;
-    }
+    assertEq(result2, r10);
+    assertEq(rest2, unsafeVec(r11));
 };
 const removeFront = (e) => (r0) => (r1) => () => {
     const v = vec(16n)(0x3456n); // -0xB456n
-    if (v !== unsafeVec(-0xb456n)) {
-        throw v;
-    }
+    assertEq(v, unsafeVec(-0xb456n));
     const r = e.removeFront(4n)(v);
-    if (r !== r0) {
-        throw r;
-    }
+    assertEq(r, r0);
     const r2 = e.removeFront(24n)(v);
-    if (r2 !== r1) {
-        throw r2;
-    }
+    assertEq(r2, r1);
 };
 const concat = (e) => (r) => () => {
     const u8 = vec(8n);
     const a = u8(0x45n); // -0xC5n
-    if (a !== unsafeVec(-0xc5n)) {
-        throw a;
-    }
+    assertEq(a, unsafeVec(-0xc5n));
     const b = u8(0x89n); // 0x89n
-    if (b !== unsafeVec(0x89n)) {
-        throw b;
-    }
+    assertEq(b, unsafeVec(0x89n));
     const ab = e.concat(a)(b); // 0x8945n
-    if (ab !== r) {
-        throw ab;
-    }
+    assertEq(ab, r);
 };
 export const proof = {
     fromSentinel: () => {
@@ -93,23 +67,15 @@ export const proof = {
         vec: () => {
             const vec4 = vec(4n);
             const v0 = vec4(5n); // 0b0101 => -0b1101
-            if (v0 !== unsafeVec(-0xdn)) {
-                throw v0;
-            }
+            assertEq(v0, unsafeVec(-0xdn));
             const v1 = vec4(0x5fen); // 0xEn
-            if (v1 !== unsafeVec(0xen)) {
-                throw v1;
-            }
+            assertEq(v1, unsafeVec(0xen));
         },
         uint: () => {
             const vector = vec(8n)(0x5n); // -0x85n
-            if (vector !== unsafeVec(-0x85n)) {
-                throw vector;
-            }
+            assertEq(vector, unsafeVec(-0x85n));
             const result = uint(vector); // result is 0x5n
-            if (result !== 0x5n) {
-                throw result;
-            }
+            assertEq(result, 0x5n);
         },
         front: () => {
             const vector = vec(8n)(0xf5n); // 0xF5n
@@ -160,51 +126,35 @@ export const proof = {
         const vector = asNominal(53n);
         const extract3Bits = lsb.front(3n);
         const result = extract3Bits(vector); // result is 0b101n (5n)
-        if (result !== 5n) {
-            throw result;
-        }
+        assertEq(result, 5n);
     },
     uintSmall: () => {
         const vector = asNominal(1n);
         const extract3Bits = lsb.front(3n)(vector);
-        if (extract3Bits !== 1n) {
-            throw extract3Bits;
-        }
+        assertEq(extract3Bits, 1n);
     },
     vecExample: () => {
         const createVector = vec(4n);
         const vector = createVector(5n); // vector is -0b1101n
-        if (vector !== unsafeVec(-13n)) {
-            throw vector;
-        }
+        assertEq(vector, unsafeVec(-13n));
     },
     length: () => {
         const len = length(empty);
-        if (len !== 0n) {
-            throw len;
-        }
+        assertEq(len, 0n);
     },
     bitset: () => {
         const v = vec(8n)(0x5fen);
-        if (v !== unsafeVec(0xfen)) {
-            throw v;
-        }
-        if (length(v) !== 8n) {
-            throw 'len';
-        }
+        assertEq(v, unsafeVec(0xfen));
+        assertEq(length(v), 8n, 'len');
         const u = lsb.front(8n)(v);
-        if (u !== 0xfen) {
-            throw v;
-        }
+        assertEq(u, 0xfen, v);
     },
     appendBack: () => {
         const vec8 = vec(8n);
         const a = vec8(0x345n);
         const b = vec8(0x789n);
         const ab = lsb.concat(a)(b);
-        if (ab !== unsafeVec(0x8945n)) {
-            throw ab;
-        }
+        assertEq(ab, unsafeVec(0x8945n));
         const s = length(ab);
         if (s !== 16n) {
             throw `appendBack: ${s}`;
@@ -212,143 +162,97 @@ export const proof = {
     },
     removeBack: () => {
         const v = vec(17n)(0x12345n);
-        if (v !== unsafeVec(0x12345n)) {
-            throw asBase(v).toString(16);
-        }
+        assertEq(v, unsafeVec(0x12345n), asBase(v).toString(16));
         const r = lsb.removeFront(9n)(v);
-        if (r !== unsafeVec(0x91n)) {
-            throw asBase(r).toString(16);
-        }
+        assertEq(r, unsafeVec(0x91n), asBase(r).toString(16));
     },
     uint: [
         // 0
         () => {
             const x = uint(asNominal(0n));
-            if (x !== 0n) {
-                throw x;
-            }
+            assertEq(x, 0n);
         },
         // 1
         () => {
             const v = asNominal(1n);
             const x = uint(v);
-            if (x !== 1n) {
-                throw x;
-            }
+            assertEq(x, 1n);
             const len = length(v);
-            if (len !== 1n) {
-                throw len;
-            }
+            assertEq(len, 1n);
         },
         // 2
         () => {
             const v = asNominal(2n);
             const x = uint(v);
-            if (x !== 2n) {
-                throw x;
-            }
+            assertEq(x, 2n);
             const len = length(v);
-            if (len !== 2n) {
-                throw len;
-            }
+            assertEq(len, 2n);
         },
         // 3
         () => {
             const v = asNominal(3n);
             const x = uint(v);
-            if (x !== 3n) {
-                throw x;
-            }
+            assertEq(x, 3n);
             const len = length(v);
-            if (len !== 2n) {
-                throw len;
-            }
+            assertEq(len, 2n);
         },
         // 4
         () => {
             const v = asNominal(-1n);
             const x = uint(v);
-            if (x !== 0n) {
-                throw x;
-            }
+            assertEq(x, 0n);
             const len = length(v);
-            if (len !== 1n) {
-                throw len;
-            }
+            assertEq(len, 1n);
         },
         () => {
             const v = asNominal(-2n);
             const x = uint(v);
-            if (x !== 0n) {
-                throw x;
-            }
+            assertEq(x, 0n);
             const len = length(v);
-            if (len !== 2n) {
-                throw len;
-            }
+            assertEq(len, 2n);
         },
         () => {
             const v = asNominal(-3n);
             const x = uint(v);
-            if (x !== 1n) {
-                throw x;
-            }
+            assertEq(x, 1n);
             const len = length(v);
-            if (len !== 2n) {
-                throw len;
-            }
+            assertEq(len, 2n);
         }
     ],
     vec: [
         // 0
         () => {
             const v = asBase(vec(0n)(0n));
-            if (v !== 0n) {
-                throw v;
-            }
+            assertEq(v, 0n);
         },
         () => {
             const v = asBase(vec(0n)(1n));
-            if (v !== 0n) {
-                throw v;
-            }
+            assertEq(v, 0n);
         },
         () => {
             const v = asBase(vec(0n)(-1n));
-            if (v !== 0n) {
-                throw v;
-            }
+            assertEq(v, 0n);
         },
         // 1
         () => {
             const v = asBase(vec(1n)(0n));
-            if (v !== -1n) {
-                throw v;
-            }
+            assertEq(v, -1n);
         },
         () => {
             const v = asBase(vec(1n)(1n));
-            if (v !== 1n) {
-                throw v;
-            }
+            assertEq(v, 1n);
         },
         () => {
             const v = asBase(vec(1n)(-1n));
-            if (v !== 1n) {
-                throw v;
-            }
+            assertEq(v, 1n);
         },
         () => {
             const v = asBase(vec(1n)(2n));
-            if (v !== -1n) {
-                throw v;
-            }
+            assertEq(v, -1n);
         },
         () => {
             const v = asBase(vec(1n)(3n));
-            if (v !== 1n) {
-                throw v;
-            }
+            assertEq(v, 1n);
         }
     ],
     both: () => {
@@ -359,14 +263,10 @@ export const proof = {
                 throw `x: ${x}, raw: ${raw}`;
             }
             const len2 = length(v);
-            if (len2 !== len) {
-                throw len2;
-            }
+            assertEq(len2, len);
             const u = uint(v);
             const mui = mask(len) & ui;
-            if (u !== mui) {
-                throw [u, mui];
-            }
+            assertEq(u, mui, [u, mui]);
         };
         // 0n
         for (const i of [0n, 1n, -1n, 2n, -2n, 3n, -3n]) {
@@ -398,14 +298,10 @@ export const proof = {
             const ab = msb.concat(a)(b);
             const abLen = length(ab);
             const abxLen = length(abx);
-            if (abLen !== abxLen) {
-                throw abLen;
-            }
+            assertEq(abLen, abxLen);
             const abU = uint(ab);
             const abxU = uint(abx);
-            if (abU !== abxU) {
-                throw abU;
-            }
+            assertEq(abU, abxU);
         };
         c(vec(4n)(0xfn))(vec(8n)(0xa7n))(vec(12n)(0xfa7n));
         c(vec(4n)(0xfn))(vec(8n)(0x57n))(vec(12n)(0xf57n));
@@ -415,28 +311,20 @@ export const proof = {
     lsbXor: () => {
         const c = (a) => (b) => (e) => {
             const r = lsb.xor(a)(b);
-            if (r !== e) {
-                throw r;
-            }
+            assertEq(r, e);
         };
         c(vec(4n)(0x7n))(vec(8n)(0x12n))(vec(8n)(0x7n ^ 0x12n));
     },
     msbXor: () => {
         const c = (a) => (b) => (e) => {
             const r = msb.xor(a)(b);
-            if (r !== e) {
-                throw r;
-            }
+            assertEq(r, e);
         };
         c(vec(4n)(0x7n))(vec(8n)(0x12n))(vec(8n)(0x70n ^ 0x12n));
     },
     repeat: () => {
-        if (repeat(4n)(vec8(0xa5n)) !== vec(32n)(0xa5a5a5a5n)) {
-            throw 'repeat failed';
-        }
-        if (repeat(7n)(vec(5n)(0x13n)) !== vec(35n)(21059194483n)) {
-            throw 'repeat failed';
-        }
+        assertEq(repeat(4n)(vec8(0xa5n)), vec(32n)(0xa5a5a5a5n), 'repeat failed');
+        assertEq(repeat(7n)(vec(5n)(0x13n)), vec(35n)(21059194483n), 'repeat failed');
     },
     lsbCmp: () => {
         const c = (a) => (b) => (r) => {
@@ -539,69 +427,39 @@ export const proof = {
     chunkList: {
         empty: () => {
             const chunks = toArray(chunkList(lsb)(4n)(empty));
-            if (chunks.length !== 0) {
-                throw chunks.length;
-            }
+            assertEq(chunks.length, 0);
         },
         // 8-bit vector 0xF5 = 0b1111_0101, aligned to 4-bit chunks
         lsb_aligned: () => {
             const chunks = toArray(chunkList(lsb)(4n)(vec(8n)(0xf5n)));
             // LSB: low nibble first — bits 0-3 = 0101 = 5, bits 4-7 = 1111 = 15
-            if (chunks.length !== 2) {
-                throw chunks.length;
-            }
-            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n) {
-                throw chunks[0];
-            }
-            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xfn) {
-                throw chunks[1];
-            }
+            assertEq(chunks.length, 2);
+            assert(!(length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n), chunks[0]);
+            assert(!(length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xfn), chunks[1]);
         },
         msb_aligned: () => {
             const chunks = toArray(chunkList(msb)(4n)(vec(8n)(0xf5n)));
             // MSB: high nibble first — bits 0-3 = 1111 = 15, bits 4-7 = 0101 = 5
-            if (chunks.length !== 2) {
-                throw chunks.length;
-            }
-            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 0xfn) {
-                throw chunks[0];
-            }
-            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 5n) {
-                throw chunks[1];
-            }
+            assertEq(chunks.length, 2);
+            assert(!(length(chunks[0]) !== 4n || uint(chunks[0]) !== 0xfn), chunks[0]);
+            assert(!(length(chunks[1]) !== 4n || uint(chunks[1]) !== 5n), chunks[1]);
         },
         // 10-bit vector 0x1B5 = 0b01_1011_0101, unaligned to 4-bit chunks (last chunk is 2 bits)
         lsb_unaligned: () => {
             const chunks = toArray(chunkList(lsb)(4n)(vec(10n)(0x1b5n)));
             // LSB: bits 0-3 = 0101 = 5, bits 4-7 = 1011 = 11, bits 8-9 = 01 = 1
-            if (chunks.length !== 3) {
-                throw chunks.length;
-            }
-            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n) {
-                throw chunks[0];
-            }
-            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xbn) {
-                throw chunks[1];
-            }
-            if (length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n) {
-                throw chunks[2];
-            }
+            assertEq(chunks.length, 3);
+            assert(!(length(chunks[0]) !== 4n || uint(chunks[0]) !== 5n), chunks[0]);
+            assert(!(length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xbn), chunks[1]);
+            assert(!(length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n), chunks[2]);
         },
         msb_unaligned: () => {
             const chunks = toArray(chunkList(msb)(4n)(vec(10n)(0x1b5n)));
             // MSB: bits 0-3 = 0110 = 6, bits 4-7 = 1101 = 13, bits 8-9 = 01 = 1
-            if (chunks.length !== 3) {
-                throw chunks.length;
-            }
-            if (length(chunks[0]) !== 4n || uint(chunks[0]) !== 6n) {
-                throw chunks[0];
-            }
-            if (length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xdn) {
-                throw chunks[1];
-            }
-            if (length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n) {
-                throw chunks[2];
-            }
+            assertEq(chunks.length, 3);
+            assert(!(length(chunks[0]) !== 4n || uint(chunks[0]) !== 6n), chunks[0]);
+            assert(!(length(chunks[1]) !== 4n || uint(chunks[1]) !== 0xdn), chunks[1]);
+            assert(!(length(chunks[2]) !== 2n || uint(chunks[2]) !== 1n), chunks[2]);
         },
     },
 };

package/{fs → fjs}/types/btree/find/module.f.js

@@ -1,4 +1,4 @@
-import { index3, index5 } from "../../function/compare/module.f.js";
+import { index3, index5 } from '../../function/compare/module.f.js';
 const child = (item) => item[1][item[0]];
 export const find = (c) => {
     const i3 = index3(c);

package/fjs/types/btree/find/proof.f.d.ts

@@ -0,0 +1,3 @@
+declare const test: () => void;
+export declare const proof: typeof test;
+export {};

package/fjs/types/btree/find/proof.f.js

@@ -0,0 +1,108 @@
+import { find as btreeFind } from './module.f.js';
+import { map, toArray } from '../../list/module.f.js';
+import { stringify } from '../../../media/json/module.f.js';
+import { sort } from '../../object/module.f.js';
+import {} from '../types/module.f.js';
+import { cmp } from '../../string/module.f.js';
+import { set as setSet } from '../set/module.f.js';
+import { assertEq } from '../../../asserts/module.f.js';
+const jsonStr = stringify(sort);
+const set = node => value => setSet(cmp(value))(() => value)(node);
+const str = r => jsonStr(toArray(map((x) => x[0])(r)));
+const find = i => m => str(btreeFind(cmp(i))(m));
+const test = () => {
+    let _map = ['1'];
+    for (let i = 2; i <= 10; i++) {
+        _map = set(_map)((i * i).toString());
+    }
+    {
+        const s = jsonStr(_map);
+        assertEq(s, '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
+    }
+    //
+    {
+        const r = find("0")(_map);
+        assertEq(r, '[0,0,0]');
+    }
+    {
+        const r = find("1")(_map);
+        assertEq(r, '[1,0,0]');
+    }
+    {
+        const r = find("10")(_map);
+        assertEq(r, '[2,0,0]');
+    }
+    {
+        const r = find("100")(_map);
+        assertEq(r, '[3,0,0]');
+    }
+    {
+        const r = find("12")(_map);
+        assertEq(r, '[4,0,0]');
+    }
+    {
+        const r = find("16")(_map);
+        assertEq(r, '[1,0]');
+    }
+    {
+        const r = find("17")(_map);
+        assertEq(r, '[0,2,0]');
+    }
+    {
+        const r = find("25")(_map);
+        assertEq(r, '[1,2,0]');
+    }
+    {
+        const r = find("26")(_map);
+        assertEq(r, '[2,2,0]');
+    }
+    {
+        const r = find("36")(_map);
+        assertEq(r, '[3,2,0]');
+    }
+    {
+        const r = find("37")(_map);
+        assertEq(r, '[4,2,0]');
+    }
+    {
+        const r = find("4")(_map);
+        assertEq(r, '[1]');
+    }
+    {
+        const r = find("41")(_map);
+        assertEq(r, '[0,0,2]');
+    }
+    {
+        const r = find("49")(_map);
+        assertEq(r, '[1,0,2]');
+    }
+    {
+        const r = find("5")(_map);
+        assertEq(r, '[2,0,2]');
+    }
+    {
+        const r = find("64")(_map);
+        assertEq(r, '[1,2]');
+    }
+    {
+        const r = find("65")(_map);
+        assertEq(r, '[0,2,2]');
+    }
+    {
+        const r = find("81")(_map);
+        assertEq(r, '[1,2,2]');
+    }
+    {
+        const r = find("85")(_map);
+        assertEq(r, '[2,2,2]');
+    }
+    {
+        const r = find("9")(_map);
+        assertEq(r, '[3,2,2]');
+    }
+    {
+        const r = find("91")(_map);
+        assertEq(r, '[4,2,2]');
+    }
+};
+export const proof = test;

package/{fs → fjs}/types/btree/module.f.js

@@ -3,8 +3,8 @@
  *
  * @module
  */
-import { flat } from "../list/module.f.js";
-import { map } from "../nullable/module.f.js";
+import { flat } from '../list/module.f.js';
+import { map } from '../nullable/module.f.js';
 const nodeValues = node => () => {
     switch (node.length) {
         case 1:

package/fjs/types/btree/proof.f.d.ts

@@ -0,0 +1,13 @@
+declare const valueTest1: () => void;
+declare const valuesTest2: () => void;
+declare const findTrue: () => void;
+declare const find: () => void;
+declare const test: () => void;
+export declare const proof: {
+    valueTest1: typeof valueTest1;
+    valuesTest2: typeof valuesTest2;
+    findTrue: typeof findTrue;
+    find: typeof find;
+    test: typeof test;
+};
+export {};