functionalscript 0.11.6 → 0.11.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.6",
+  "version": "0.11.8",
   "type": "module",
   "files": [
     "**/*.js",

package/types/bit_vec/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Fold, Reduce as OpReduce } from '../function/operator/module.f.ts';
+import type { Binary, Fold, Reduce as OpReduce } from '../function/operator/module.f.ts';
 import { type List, type Thunk } from '../list/module.f.ts';
 import { type Nominal } from '../nominal/module.f.ts';
 import { type Sign } from '../function/compare/module.f.ts';
@@ -56,7 +56,13 @@ export declare const unpack: (v: Vec) => Unpacked;
  * Packs an unpacked representation back into a vector.
  */
 export declare const pack: ({ length, uint }: Unpacked) => Vec;
+type Norm = (len: bigint) => {
+    readonly a: bigint;
+    readonly b: bigint;
+};
+type NormOp = Binary<Unpacked, Unpacked, Norm>;
 export type Reduce = OpReduce<Vec>;
+export type PopFront<T> = (len: bigint) => (u: T) => readonly [bigint, T];
 /**
  * Represents operations for handling bit vectors with a specific bit order.
  *
@@ -121,7 +127,7 @@ export type BitOrder = {
      * const [uM1, rM1] = msb.popFront(16n)(vector) // [0xF500n, rM1 === empty]
      * ```
      */
-    readonly popFront: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
+    readonly popFront: PopFront<Vec>;
     /**
      * Concatenates two vectors.
      *
@@ -145,6 +151,8 @@ export type BitOrder = {
      * @returns A function that takes a second vector and returns the XOR result.
      */
     readonly xor: Reduce;
+    readonly unpackPopFront: PopFront<Unpacked>;
+    readonly norm: NormOp;
 };
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
@@ -169,7 +177,7 @@ export declare const msb: BitOrder;
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export declare const u8ListToVec: (bo: BitOrder) => (list: List<number>) => Vec;
+export declare const u8ListToVec: ({ concat }: BitOrder) => (list: List<number>) => Vec;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
@@ -177,7 +185,7 @@ export declare const u8ListToVec: (bo: BitOrder) => (list: List<number>) => Vec;
  * @param v The vector to be converted.
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
-export declare const u8List: ({ popFront }: BitOrder) => (v: Vec) => Thunk<number>;
+export declare const u8List: ({ unpackPopFront }: BitOrder) => (v: Vec) => Thunk<number>;
 /**
  * Concatenates a list of vectors using the provided bit order.
  */
@@ -197,3 +205,4 @@ export declare const isVec: <T>(v: Vec | T) => v is Vec;
  * a === b => 0
  */
 export declare const msbCmp: (av: Vec) => (bv: Vec) => Sign;
+export {};

package/types/bit_vec/module.f.js

@@ -23,7 +23,7 @@
  */
 import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
-import { fold } from "../list/module.f.js";
+import { fold, iterable } from "../list/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
 import { repeat as mRepeat } from "../monoid/module.f.js";
 import { cmp } from "../function/compare/module.f.js";
@@ -97,8 +97,6 @@ export const unpack = (v) => ({
  * Packs an unpacked representation back into a vector.
  */
 export const pack = ({ length, uint }) => vec(length)(uint);
-const lsbNorm = ({ length: al, uint: a }) => ({ length: bl, uint: b }) => (len) => ({ a, b });
-const msbNorm = ({ length: al, uint: a }) => ({ length: bl, uint: b }) => (len) => ({ a: a << (len - al), b: b << (len - bl) });
 /**
  * Normalizes two vectors to the same length before applying a bigint reducer.
  */
@@ -109,6 +107,30 @@ const op = (norm) => (op) => ap => bp => {
     const { a, b } = norm(au)(bu)(len);
     return vec(len)(op(a)(b));
 };
+const bo = ({ front, removeFront, concat, rawPopFront, norm }) => {
+    const unpackPopFront = (len) => {
+        const m = mask(len);
+        return (v) => {
+            const [uint, rest] = rawPopFront(len)(v);
+            return [uint & m, rest];
+        };
+    };
+    return {
+        front,
+        removeFront,
+        concat,
+        xor: op(norm)(xor),
+        unpackPopFront,
+        popFront: len => {
+            const f = unpackPopFront(len);
+            return v => {
+                const [uint, u] = f(unpack(v));
+                return [uint, pack(u)];
+            };
+        },
+        norm,
+    };
+};
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
@@ -116,7 +138,7 @@ const op = (norm) => (op) => ap => bp => {
  *
  * Usually associated with Little-Endian (LE) byte order.
  */
-export const lsb = {
+export const lsb = bo({
     front: len => {
         const m = mask(len);
         return v => uint(v) & m;
@@ -125,20 +147,14 @@ export const lsb = {
         const { length, uint } = unpack(v);
         return vec(length - len)(uint >> len);
     },
-    popFront: len => {
-        const m = mask(len);
-        return v => {
-            const { length, uint } = unpack(v);
-            return [uint & m, vec(length - len)(uint >> len)];
-        };
-    },
     concat: (a) => (b) => {
         const { length: al, uint: au } = unpack(a);
         const { length: bl, uint: bu } = unpack(b);
         return vec(al + bl)((bu << al) | au);
     },
-    xor: op(lsbNorm)(xor)
-};
+    norm: ({ uint: a }) => ({ uint: b }) => () => ({ a, b }),
+    rawPopFront: len => ({ length, uint }) => [uint, { length: length - len, uint: uint >> len }]
+});
 /**
  * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
  *
@@ -146,7 +162,7 @@ export const lsb = {
  *
  * Usually associated with Big-Endian (BE) byte order.
  */
-export const msb = {
+export const msb = bo({
     front: len => {
         const m = mask(len);
         return v => {
@@ -158,18 +174,13 @@ export const msb = {
         const { length, uint } = unpack(v);
         return vec(length - len)(uint);
     },
-    popFront: len => {
-        const m = mask(len);
-        return v => {
-            const { length, uint } = unpack(v);
-            const d = length - len;
-            return [(uint >> d) & m, vec(d)(uint)];
-        };
-    },
     concat: flip(lsb.concat),
-    xor: op(msbNorm)(xor)
-};
-const appendU8 = ({ concat }) => (u8) => (a) => concat(a)(vec8(BigInt(u8)));
+    norm: ({ length: al, uint: a }) => ({ length: bl, uint: b }) => len => ({ a: a << (len - al), b: b << (len - bl) }),
+    rawPopFront: len => ({ length, uint }) => {
+        const d = length - len;
+        return [uint >> d, { length: d, uint }];
+    }
+});
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -177,7 +188,34 @@ const appendU8 = ({ concat }) => (u8) => (a) => concat(a)(vec8(BigInt(u8)));
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export const u8ListToVec = (bo) => fold(appendU8(bo))(empty);
+export const u8ListToVec = ({ concat }) => (list) => {
+    // much faster than: `fold(appendU8(bo))(empty)(list)`
+    // where `appendU8` is defined as
+    // ```
+    // const appendU8 = ({ concat }: BitOrder) => (u8: number) => (a: Vec) =>
+    //    concat(a)(vec8(BigInt(u8)))
+    // ```
+    let result = [];
+    for (const b of iterable(list)) {
+        let v = vec8(BigInt(b));
+        let i = 0;
+        while (true) {
+            if (result.length <= i) {
+                result = [...result, v];
+                break;
+            }
+            const old = result[i];
+            if (old === empty) {
+                result = result.toSpliced(i, 1, v);
+                break;
+            }
+            result = result.toSpliced(i, 1, empty);
+            v = concat(old)(v);
+            i++;
+        }
+    }
+    return result.reduce((p, c) => concat(c)(p), empty);
+};
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
@@ -185,15 +223,16 @@ export const u8ListToVec = (bo) => fold(appendU8(bo))(empty);
  * @param v The vector to be converted.
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
-export const u8List = ({ popFront }) => {
-    const f = (v) => () => {
-        if (v === empty) {
+export const u8List = ({ unpackPopFront }) => {
+    const pf = unpackPopFront(8n);
+    const f = (u) => () => {
+        if (u.length <= 0n) {
             return null;
         }
-        const [first, tail] = popFront(8n)(v);
+        const [first, tail] = pf(u);
         return { first: Number(first), tail: f(tail) };
     };
-    return f;
+    return v => f(unpack(v));
 };
 /**
  * Concatenates a list of vectors using the provided bit order.
@@ -218,7 +257,7 @@ export const msbCmp = (av) => (bv) => {
     const bu = unpack(bv);
     const al = au.length;
     const bl = bu.length;
-    const { a, b } = msbNorm(au)(bu)(min(al)(bl));
+    const { a, b } = msb.norm(au)(bu)(min(al)(bl));
     const result = cmp(a)(b);
     return result !== 0 ? result : cmp(al)(bl);
 };

package/types/bit_vec/test.f.d.ts

@@ -38,5 +38,7 @@ declare const _default: {
     msbXor: () => void;
     repeat: () => void;
     msbCmp: () => void;
+    u8ListToVec: () => () => void;
+    u8ListUnaligned: () => void;
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,7 @@
 import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, msbCmp, u8ListToVec, u8List } 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
@@ -442,5 +443,30 @@ export default {
         c(vec(4n)(0x5n))(vec(5n)(0x5n))(1); // 0b0101_ < 0b00101
         c(vec(5n)(0x5n))(vec(4n)(0x5n))(-1); // 0b00101 < 0b0101_
         c(vec(4n)(0x5n))(vec(5n)(0xan))(-1); // 0b0101_ < 0b01010
+    },
+    u8ListToVec: () => {
+        // 131_072 is too much for Bun
+        const x = u8ListToVec(msb)(listRepeat(0x12)(131_071));
+        return () => {
+            const m = u8List(msb)(x);
+            const y = toArray(m);
+            if (y.length !== 131_071) {
+                throw y.length;
+            }
+        };
+    },
+    u8ListUnaligned: () => {
+        const x = vec(9n)(0x83n);
+        const a = toArray(u8List(msb)(x));
+        if (a.length !== 2) {
+            throw a;
+        }
+        const [a0, a1] = a;
+        if (a0 !== 0x41) {
+            throw `a0: ${a0.toString(16)}`;
+        }
+        if (a1 !== 0x80) {
+            throw `a1: ${a1.toString(16)}`;
+        }
     }
 };