functionalscript 0.37.0 → 0.39.0

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

@@ -1,4 +1,4 @@
-import { assertEq } from '../../asserts/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';
@@ -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/proof.f.js

@@ -5,6 +5,7 @@ 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)));
@@ -16,136 +17,92 @@ const test = () => {
     }
     {
         const s = jsonStr(_map);
-        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {
-            throw s;
-        }
+        assertEq(s, '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]');
     }
     //
     {
         const r = find("0")(_map);
-        if (r !== '[0,0,0]') {
-            throw r;
-        }
+        assertEq(r, '[0,0,0]');
     }
     {
         const r = find("1")(_map);
-        if (r !== '[1,0,0]') {
-            throw r;
-        }
+        assertEq(r, '[1,0,0]');
     }
     {
         const r = find("10")(_map);
-        if (r !== '[2,0,0]') {
-            throw r;
-        }
+        assertEq(r, '[2,0,0]');
     }
     {
         const r = find("100")(_map);
-        if (r !== '[3,0,0]') {
-            throw r;
-        }
+        assertEq(r, '[3,0,0]');
     }
     {
         const r = find("12")(_map);
-        if (r !== '[4,0,0]') {
-            throw r;
-        }
+        assertEq(r, '[4,0,0]');
     }
     {
         const r = find("16")(_map);
-        if (r !== '[1,0]') {
-            throw r;
-        }
+        assertEq(r, '[1,0]');
     }
     {
         const r = find("17")(_map);
-        if (r !== '[0,2,0]') {
-            throw r;
-        }
+        assertEq(r, '[0,2,0]');
     }
     {
         const r = find("25")(_map);
-        if (r !== '[1,2,0]') {
-            throw r;
-        }
+        assertEq(r, '[1,2,0]');
     }
     {
         const r = find("26")(_map);
-        if (r !== '[2,2,0]') {
-            throw r;
-        }
+        assertEq(r, '[2,2,0]');
     }
     {
         const r = find("36")(_map);
-        if (r !== '[3,2,0]') {
-            throw r;
-        }
+        assertEq(r, '[3,2,0]');
     }
     {
         const r = find("37")(_map);
-        if (r !== '[4,2,0]') {
-            throw r;
-        }
+        assertEq(r, '[4,2,0]');
     }
     {
         const r = find("4")(_map);
-        if (r !== '[1]') {
-            throw r;
-        }
+        assertEq(r, '[1]');
     }
     {
         const r = find("41")(_map);
-        if (r !== '[0,0,2]') {
-            throw r;
-        }
+        assertEq(r, '[0,0,2]');
     }
     {
         const r = find("49")(_map);
-        if (r !== '[1,0,2]') {
-            throw r;
-        }
+        assertEq(r, '[1,0,2]');
     }
     {
         const r = find("5")(_map);
-        if (r !== '[2,0,2]') {
-            throw r;
-        }
+        assertEq(r, '[2,0,2]');
     }
     {
         const r = find("64")(_map);
-        if (r !== '[1,2]') {
-            throw r;
-        }
+        assertEq(r, '[1,2]');
     }
     {
         const r = find("65")(_map);
-        if (r !== '[0,2,2]') {
-            throw r;
-        }
+        assertEq(r, '[0,2,2]');
     }
     {
         const r = find("81")(_map);
-        if (r !== '[1,2,2]') {
-            throw r;
-        }
+        assertEq(r, '[1,2,2]');
     }
     {
         const r = find("85")(_map);
-        if (r !== '[2,2,2]') {
-            throw r;
-        }
+        assertEq(r, '[2,2,2]');
     }
     {
         const r = find("9")(_map);
-        if (r !== '[3,2,2]') {
-            throw r;
-        }
+        assertEq(r, '[3,2,2]');
     }
     {
         const r = find("91")(_map);
-        if (r !== '[4,2,2]') {
-            throw r;
-        }
+        assertEq(r, '[4,2,2]');
     }
 };
 export const proof = test;