functionalscript 0.12.6 → 0.12.7

package/package.json

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

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

@@ -188,6 +188,16 @@ export declare const msb: BitOrder;
  * @returns The resulting vector based on the provided bit order.
  */
 export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Vec;
+/**
+ * Chunks a bit vector into fixed-size pieces of `n` bits using the provided bit order.
+ * The last chunk may be smaller than `n` bits if the vector length is not a multiple of `n`.
+ *
+ * @param bitOrder The bit order for the conversion.
+ * @param n The chunk size in bits.
+ * @param v The vector to be chunked.
+ * @returns A thunk that produces a list of bit vectors, each representing one chunk.
+ */
+export declare const chunkList: ({ unpackSplit }: BitOrder) => (n: bigint) => (v: Vec) => Thunk<Vec>;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
@@ -195,7 +205,7 @@ export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<nu
  * @param v The vector to be converted.
  * @returns A thunk that produces a list of unsigned 8-bit integers.
  */
-export declare const u8List: ({ unpackSplit }: BitOrder) => (v: Vec) => Thunk<number>;
+export declare const u8List: (bo: BitOrder) => (v: Vec) => Thunk<number>;
 /**
  * Concatenates a list of vectors using the provided bit order.
  */

package/types/bit_vec/module.f.js

@@ -21,9 +21,9 @@
  *
  * @module
  */
-import { bitLength, mask, max, min, xor } from "../bigint/module.f.js";
+import { bitLength, divUp, mask, max, min, xor } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
-import { fold, iterable } from "../list/module.f.js";
+import { fold, iterable, map } 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";
@@ -230,37 +230,54 @@ export const u8ListToVec = ({ unpackConcat }) => (list) => {
     return pack(result.reduce((p, c) => unpackConcat(c)(p), unpackEmpty));
 };
 /**
- * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
+ * Chunks a bit vector into fixed-size pieces of `n` bits using the provided bit order.
+ * The last chunk may be smaller than `n` bits if the vector length is not a multiple of `n`.
  *
  * @param bitOrder The bit order for the conversion.
- * @param v The vector to be converted.
- * @returns A thunk that produces a list of unsigned 8-bit integers.
+ * @param n The chunk size in bits.
+ * @param v The vector to be chunked.
+ * @returns A thunk that produces a list of bit vectors, each representing one chunk.
  */
-export const u8List = ({ unpackSplit }) => (v) => {
-    if (v === empty) {
-        return () => null;
-    }
-    const f = (stack) => () => {
-        while (true) {
-            const [first, rest] = stack;
-            const { length, uint } = first;
-            if (length <= 8n) {
-                // the last unpack split is required to align data.
-                const v = length < 8n ? unpackSplit(8n)(first)[0] : uint;
-                return { first: Number(v), tail: rest !== undefined ? f(rest) : null };
-            }
-            // `length` is bigger than `8n` so `newLen` is `8n` or bigger.
-            const aLength = ((length + 7n) >> 4n) << 3n;
-            const bLength = length - aLength;
-            const [a, b] = unpackSplit(aLength)(first);
-            stack = [
-                { length: aLength, uint: a & mask(aLength) },
-                [{ length: bLength, uint: b & mask(bLength) }, rest],
-            ];
+export const chunkList = ({ unpackSplit }) => (n) => {
+    const divUpN2 = divUp(n << 1n);
+    return v => {
+        if (v === empty) {
+            return () => null;
         }
+        const f = (stack) => () => {
+            while (true) {
+                const [first, rest] = stack;
+                const { length } = first;
+                if (length <= n) {
+                    return { first: pack(first), tail: rest !== undefined ? f(rest) : null };
+                }
+                const aLength = divUpN2(length) * n;
+                const bLength = length - aLength;
+                const [a, b] = unpackSplit(aLength)(first);
+                stack = [
+                    { length: aLength, uint: a & mask(aLength) },
+                    [{ length: bLength, uint: b & mask(bLength) }, rest],
+                ];
+            }
+        };
+        return f([unpack(v), undefined]);
     };
-    return f([unpack(v), undefined]);
 };
+const vecToU8 = ({ unpackSplit }) => {
+    const unpackSplit8 = unpackSplit(8n);
+    return chunk => {
+        const u = unpack(chunk);
+        return Number(u.length < 8n ? unpackSplit8(u)[0] : u.uint);
+    };
+};
+/**
+ * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
+ *
+ * @param bitOrder The bit order for the conversion.
+ * @param v The vector to be converted.
+ * @returns A thunk that produces a list of unsigned 8-bit integers.
+ */
+export const u8List = (bo) => (v) => map(vecToU8(bo))(chunkList(bo)(8n)(v));
 /**
  * Concatenates a list of vectors using the provided bit order.
  */

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

@@ -41,5 +41,12 @@ declare const _default: {
     msbCmp: () => void;
     u8ListToVec: () => () => void;
     u8ListUnaligned: () => void;
+    chunkList: {
+        empty: () => void;
+        lsb_aligned: () => void;
+        msb_aligned: () => void;
+        lsb_unaligned: () => void;
+        msb_unaligned: () => void;
+    };
 };
 export default _default;

package/types/bit_vec/test.f.js

@@ -1,6 +1,6 @@
 import { mask } from "../bigint/module.f.js";
 import { asBase, asNominal } from "../nominal/module.f.js";
-import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List } from "./module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, u8ListToVec, u8List, chunkList } from "./module.f.js";
 import { repeat as listRepeat, toArray } from "../list/module.f.js";
 const unsafeVec = (a) => asNominal(a);
 // 0x8 = 0b1000 = 0 + 8
@@ -482,5 +482,73 @@ export default {
         if (a1 !== 0x80) {
             throw `a1: ${a1.toString(16)}`;
         }
-    }
+    },
+    chunkList: {
+        empty: () => {
+            const chunks = toArray(chunkList(lsb)(4n)(empty));
+            if (chunks.length !== 0) {
+                throw chunks.length;
+            }
+        },
+        // 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];
+            }
+        },
+        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];
+            }
+        },
+        // 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];
+            }
+        },
+        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];
+            }
+        },
+    },
 };