functionalscript 0.37.0 → 0.39.0

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

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

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

@@ -17,7 +17,8 @@
  * ```
  */
 import { cmp } from '../function/compare/module.f.js';
-import { reduce } from '../list/module.f.js';
+import {} from '../list/module.f.js';
+import { fold } from '../../common/monoid/module.f.js';
 /**
  * Adds two `bigint` values.
  *
@@ -31,7 +32,7 @@ export const addition = a => b => a + b;
  * @param input - A list of bigint values.
  * @returns The sum of all values in the list.
  */
-export const sum = reduce(addition)(0n);
+export const sum = fold({ identity: 0n, operation: addition });
 /**
  * Multiplies two `bigint` values.
  *
@@ -45,7 +46,7 @@ export const multiple = a => b => a * b;
  * @param input - A list of bigint values.
  * @returns The product of all values in the list.
  */
-export const product = reduce(multiple)(1n);
+export const product = fold({ identity: 1n, operation: multiple });
 /**
  * Calculates the absolute value of a `bigint`.
  *

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

@@ -1,5 +1,5 @@
 import { sum, abs, serialize, log2, bitLength, mask, combination, factorial, xor, multiple, product, divUp, roundUp, divUp8, roundUp8 } from './module.f.js';
-import { assertEq } from '../../asserts/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 import { min } from '../function/compare/module.f.js';
 const oldLog2 = (v) => {
     if (v <= 0n) {
@@ -116,15 +116,11 @@ const benchmark = f => () => {
     for (let i = 0n; i < 1_100; ++i) {
         {
             const x = f(c);
-            if (x !== e) {
-                throw x;
-            }
+            assertEq(x, e);
         }
         {
             const x = f(c - 1n);
-            if (x !== e - 1n) {
-                throw [e, x];
-            }
+            assertEq(x, e - 1n, [e, x]);
         }
         c >>= 1n;
         --e;
@@ -136,15 +132,11 @@ const benchmarkSmall = f => () => {
     do {
         {
             const x = f(c);
-            if (x !== e) {
-                throw [e, x];
-            }
+            assertEq(x, e, [e, x]);
         }
         for (let j = 1n; j < min(c >> 1n)(1000n); ++j) {
             const x = f(c - j);
-            if (x !== e - 1n) {
-                throw [j, e, x];
-            }
+            assertEq(x, e - 1n, [j, e, x]);
         }
         c >>= 1n;
         --e;
@@ -153,33 +145,19 @@ const benchmarkSmall = f => () => {
 export const proof = {
     example: () => {
         const total = sum([1n, 2n, 3n]); // 6n
-        if (total !== 6n) {
-            throw total;
-        }
+        assertEq(total, 6n);
         const absoluteValue = abs(-42n); // 42n
-        if (absoluteValue !== 42n) {
-            throw absoluteValue;
-        }
+        assertEq(absoluteValue, 42n);
         const logValue = log2(8n); // 3n
-        if (logValue !== 3n) {
-            throw logValue;
-        }
+        assertEq(logValue, 3n);
         const bitCount = bitLength(255n); // 8n
-        if (bitCount !== 8n) {
-            throw bitCount;
-        }
+        assertEq(bitCount, 8n);
         const bitmask = mask(5n); // 31n
-        if (bitmask !== 31n) {
-            throw benchmark;
-        }
+        assertEq(bitmask, 31n, benchmark);
         const m = min(3n)(13n); // 3n
-        if (m !== 3n) {
-            throw m;
-        }
+        assertEq(m, 3n);
         const c = combination(3n, 2n, 1n); // 60n
-        if (c !== 60n) {
-            throw c;
-        }
+        assertEq(c, 60n);
     },
     benchmark: () => {
         const list = {
@@ -199,142 +177,100 @@ export const proof = {
     },
     mask: () => {
         const result = mask(3n); // 7n
-        if (result !== 7n) {
-            throw result;
-        }
+        assertEq(result, 7n);
     },
     sum: () => {
         const result = sum([2n, 3n, 4n, 5n]);
-        if (result !== 14n) {
-            throw result;
-        }
+        assertEq(result, 14n);
     },
     abs: [
         () => {
             const result = abs(10n);
-            if (result !== 10n) {
-                throw result;
-            }
+            assertEq(result, 10n);
         },
         () => {
             const result = abs(-10n);
-            if (result !== 10n) {
-                throw result;
-            }
+            assertEq(result, 10n);
         }
     ],
     serialize: [
         () => {
             const result = serialize(0n);
-            if (result !== '0n') {
-                throw result;
-            }
+            assertEq(result, '0n');
         },
         () => {
             const result = serialize(123456789012345678901234567890n);
-            if (result !== '123456789012345678901234567890n') {
-                throw result;
-            }
+            assertEq(result, '123456789012345678901234567890n');
         },
         () => {
             const result = serialize(-55555n);
-            if (result !== '-55555n') {
-                throw result;
-            }
+            assertEq(result, '-55555n');
         },
     ],
     log2: [
         () => {
             const result = log2(-3n);
-            if (result !== -1n) {
-                throw result;
-            }
+            assertEq(result, -1n);
         },
         () => {
             const result = log2(0n);
-            if (result !== -1n) {
-                throw result;
-            }
+            assertEq(result, -1n);
         },
         () => {
             const result = log2(1n);
-            if (result !== 0n) {
-                throw result;
-            }
+            assertEq(result, 0n);
         },
         () => {
             const result = log2(2n);
-            if (result !== 1n) {
-                throw result;
-            }
+            assertEq(result, 1n);
         },
         () => {
             const result = log2(3n);
-            if (result !== 1n) {
-                throw result;
-            }
+            assertEq(result, 1n);
         },
         () => {
             const result = log2(4n);
-            if (result !== 2n) {
-                throw result;
-            }
+            assertEq(result, 2n);
         },
         () => {
             const result = log2(7n);
-            if (result !== 2n) {
-                throw result;
-            }
+            assertEq(result, 2n);
         },
         () => {
             const result = log2(8n);
-            if (result !== 3n) {
-                throw result;
-            }
+            assertEq(result, 3n);
         },
         () => {
             const result = log2(15n);
-            if (result !== 3n) {
-                throw result;
-            }
+            assertEq(result, 3n);
         },
         () => {
             const result = log2(16n);
-            if (result !== 4n) {
-                throw result;
-            }
+            assertEq(result, 4n);
         },
         () => {
             // max for Bun (131_072 Bytes)
             const v = 1048575n;
             const result = log2(1n << v);
-            if (result !== v) {
-                throw result;
-            }
+            assertEq(result, v);
         },
         () => {
             const v = 0x18945n;
             const result = log2(v);
-            if (result !== 16n) {
-                throw result;
-            }
+            assertEq(result, 16n);
         }
     ],
     toString2: () => {
         // max for Bun (131_072 Bytes)
         const v = 1048575n;
         const result = (1n << v).toString(2).length - 1;
-        if (result !== 1_048_575) {
-            throw result;
-        }
+        assertEq(result, 1_048_575);
     },
     minus: () => {
         let i = 0n;
         while (i < 1048575n) {
             const s = -i;
-            if (i !== -s) {
-                throw [i, s];
-            }
+            assertEq(i, -s, [i, s]);
             i += 1n;
         }
     },
@@ -342,106 +278,76 @@ export const proof = {
         let i = 0n;
         while (i < 1048575n) {
             const s = ~i;
-            if (i !== ~s) {
-                throw [i, s];
-            }
+            assertEq(i, ~s, [i, s]);
             i += 1n;
         }
     },
     bitLen: {
         0: () => {
             const s = bitLength(0n);
-            if (s !== 0n) {
-                throw s;
-            }
+            assertEq(s, 0n);
         },
         m: () => {
             let i = 0n;
             while (i < 10000n) {
                 const s = bitLength(1n << i);
-                if (s !== i + 1n) {
-                    throw [s, i];
-                }
+                assertEq(s, i + 1n, [s, i]);
                 i += 1n;
             }
         },
         big: () => {
             const s = bitLength(1n << 1000000n);
-            if (s !== 1000001n) {
-                throw s;
-            }
+            assertEq(s, 1000001n);
         },
         neg: [
             () => {
                 const s = bitLength(-1n);
-                if (s !== 1n) {
-                    throw s;
-                }
+                assertEq(s, 1n);
             },
             () => {
                 const s = bitLength(-2n);
-                if (s !== 2n) {
-                    throw s;
-                }
+                assertEq(s, 2n);
             },
             () => {
                 const s = bitLength(-3n);
-                if (s !== 2n) {
-                    throw s;
-                }
+                assertEq(s, 2n);
             },
             () => {
                 const s = bitLength(-4n);
-                if (s !== 3n) {
-                    throw s;
-                }
+                assertEq(s, 3n);
             },
         ]
     },
     factorial: () => {
         {
             const r = factorial(3n);
-            if (r !== 6n) {
-                throw r;
-            }
+            assertEq(r, 6n);
         }
         {
             const r = factorial(5n);
-            if (r !== 120n) {
-                throw r;
-            }
+            assertEq(r, 120n);
         }
     },
     combination: () => {
         const r = combination(2n, 3n);
-        if (r != 120n / (2n * 6n)) {
-            throw r;
-        }
+        assert(r == 120n / (2n * 6n), r);
     },
     combination50x50: () => {
         {
             const r = combination(1n, 1n);
-            if (r !== 2n) {
-                throw r;
-            }
+            assertEq(r, 2n);
         }
         {
             const r = combination(2n, 2n);
-            if (r !== 6n) {
-                throw r;
-            }
+            assertEq(r, 6n);
         }
         {
             const r = combination(3n, 3n);
-            if (r !== 20n) {
-                throw r;
-            }
+            assertEq(r, 20n);
         }
         {
             const r = combination(4n, 4n);
-            if (r !== 70n) {
-                throw r;
-            }
+            assertEq(r, 70n);
         }
     },
     combination3: () => {
@@ -450,9 +356,7 @@ export const proof = {
         // 2+3+4+2 = 5*6*7*8*9*10*11
         // e = 5 * 6 * 7 * 8 * 9 * 10 * 11 / (2n * 2n * 6n) =
         // e = 5     * 7 * 2 * 9 * 10 * 11 = 69300
-        if (r !== 69300n) {
-            throw r;
-        }
+        assertEq(r, 69300n);
     },
     divUp: () => {
         assertEq(divUp(8n)(8n), 1n);

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

@@ -23,7 +23,7 @@
  */
 import { bitLength, divUp, mask, maxLength, xor } from '../bigint/module.f.js';
 import { flip, identity } from '../function/module.f.js';
-import { iterable, map } from '../list/module.f.js';
+import { map, tryFold } from '../list/module.f.js';
 import { asBase, asNominal } from '../nominal/module.f.js';
 import { repeat as mRepeat } from '../../common/monoid/module.f.js';
 import { cmp, max, min } from '../function/compare/module.f.js';
@@ -174,24 +174,14 @@ const listToVecOp = (unpackConcat) => ({
  * the final reduce prepends higher (earlier) slots in front of accumulated
  * later runs. An empty list yields `unpackEmpty`.
  *
+ * Returns `null` as soon as the accumulated length exceeds `maxLength`, which
+ * `tryFold` propagates by abandoning the rest of the list.
+ *
  * This is the bit-vector analogue of a builder that accumulates appended pieces
  * and materializes the combined result on demand, such as `StringBuilder`
  * (Java, C#) or `strings.Builder` (Go).
  */
-const unpackListToVec = (unpackConcat) => {
-    const { init, update, end } = listToVecOp(unpackConcat);
-    return (list) => {
-        let result = init;
-        for (const e of iterable(list)) {
-            const candidate = update(e, result);
-            if (candidate === null) {
-                return null;
-            }
-            result = candidate;
-        }
-        return end(result);
-    };
-};
+const unpackListToVec = (unpackConcat) => tryFold(listToVecOp(unpackConcat));
 const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
     const unpackPopFront = (len) => {
         const m = mask(len);