functionalscript 0.3.7 → 0.3.9

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

@@ -1,7 +1,8 @@
+import { type List, type Thunk } from '../list/module.f.ts';
 /**
  * A vector of bits represented as a `bigint`.
  */
-type Vec = bigint;
+export type Vec = bigint;
 /**
  * An empty vector of bits.
  */
@@ -22,6 +23,10 @@ export declare const length: (v: bigint) => bigint;
  * ```
  */
 export declare const vec: (len: bigint) => (ui: bigint) => Vec;
+/**
+ * Creates an 8 bit vector from an unsigned integer.
+ */
+export declare const vec8: (u: bigint) => Vec;
 /**
  * Returns the unsigned integer of the given vector by removing a stop bit.
  *
@@ -34,101 +39,116 @@ export declare const vec: (len: bigint) => (ui: bigint) => Vec;
  */
 export declare const uint: (v: Vec) => bigint;
 /**
- * Extract the least significant unsigned integer from the given vector.
- *
- * @example
+ * Represents operations for handling bit vectors with a specific bit order.
  *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const result = uintLsb(4n)(vector); // result is 5n
- * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
- * ```
+ * https://en.wikipedia.org/wiki/Bit_numbering
  */
-export declare const uintLsb: (len: bigint) => (v: Vec) => bigint;
+export type BitOrder = {
+    /**
+     * Retrieves the first unsigned integer of the specified length from the given vector.
+     *
+     * @param len - The number of bits to read from the start of the vector.
+     * @returns A function that takes a vector and returns the extracted unsigned integer.
+     *
+     * @example
+     *
+     * ```js
+     * const vector = vec(8n)(0xF5n) // 0x1F5n
+     *
+     * const resultL0 = lsb.front(4n)(vector)  // resultL0 is 5n
+     * const resultL1 = lsb.front(16n)(vector) // resultL1 is 0xF5n
+     *
+     * const resultM0 = msb.front(4n)(vector)  // resultM0 is 0xFn
+     * const resultM1 = msb.front(16n)(vector) // resultM1 is 0xF500n
+     * ```
+     */
+    readonly front: (len: bigint) => (v: Vec) => bigint;
+    /**
+     * Removes a specified number of bits from the start of the given vector.
+     *
+     * @param len - The number of bits to remove from the vector.
+     * @returns A function that takes a vector and returns the remaining vector.
+     *
+     * @example
+     *
+     * ```js
+     * const v = vec(16n)(0x3456n) // 0x13456n
+     *
+     * const rL0 = lsb.removeFront(4n)(v)  // 0x1345n
+     * const rL1 = lsb.removeFront(24n)(v) // 0x1n
+     *
+     * const rM0 = msb.removeFront(4n)(v)  // 0x1456n
+     * const rM1 = msb.removeFront(24n)(v) // 0x1n
+     * ```
+     */
+    readonly removeFront: (len: bigint) => (v: Vec) => Vec;
+    /**
+     * Removes a specified number of bits from the start of the vector and returns
+     * the removed bits and the remaining vector.
+     *
+     * @param len - The number of bits to remove from the vector.
+     * @returns A function that takes a vector and returns
+     * a tuple containing the removed bits as an unsigned integer and the remaining vector.
+     *
+     * ```js
+     * const vector = vec(8n)(0xF5n) // 0x1F5n
+     *
+     * const [uL0, rL0] = lsb.popFront(4n)(vector)  // [5n, 0x1Fn]
+     * const [uL1, rL1] = lsb.popFront(16n)(vector) // [0xF5n, 1n]
+     *
+     * const [uM0, rM0] = msb.popFront(4n)(vector)  // [0xFn, 0x15n]
+     * const [uM1, rM1] = msb.popFront(16n)(vector) // [0xF500n, 1n]
+     * ```
+     */
+    readonly popFront: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
+    /**
+     * Concatenates two vectors.
+     *
+     * @param a - The first vector.
+     * @returns A function that takes a second vector and returns the concatenated vector.
+     *
+     * @example
+     *
+     * ```js
+     * const u8 = vec(8n)
+     * const a = u8(0x45n) // 0x145n
+     * const b = u8(0x89n) // 0x189n
+     *
+     * const abL = lsb.concat(a)(b) // 0x18945n
+     * const abM = msb.concat(a)(b) // 0x14589n
+     * ```
+     */
+    readonly concat: (a: Vec) => (b: Vec) => Vec;
+};
 /**
- * Removes the first `len` least significant bits from the given vector.
+ * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
- * @example
+ * https://en.wikipedia.org/wiki/Bit_numbering#LSb_0_bit_numbering
  *
- * ```js
- * const v = vec(16n)(0x3456n) // 0x13456n
- * const r = removeLsb(4n)(v) // 0x1345n
- * const r2 = removeLsb(24n)(v) // 0x1n
- * ```
+ * Usually associated with Little-Endian (LE) byte order.
  */
-export declare const removeLsb: (len: bigint) => (v: Vec) => Vec;
+export declare const lsb: BitOrder;
 /**
- * Extracts the least significant unsigned integer and removes it from the vector.
+ * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
  *
- * @example
+ * https://en.wikipedia.org/wiki/Bit_numbering#MSb_0_bit_numbering
  *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
- * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
- * ```
+ * Usually associated with Big-Endian (BE) byte order.
  */
-export declare const popUintLsb: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
+export declare const msb: BitOrder;
 /**
- * Extract the most significant unsigned integer of the given `len` from the given vector.
- *
- * @example
+ * Converts a list of unsigned 8-bit integers to a bit vector.
  *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const result = uintMsb(4n)(vector); // result is 0xFn
- * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
- * ```
+ * @param bo The bit order for the conversion
+ * @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 uintMsb: (len: bigint) => (v: Vec) => bigint;
+export declare const u8ListToVec: (bo: BitOrder) => (list: List<number>) => Vec;
 /**
- * Removes the first `len` most significant bits from the given vector.
+ * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
- * @example
- *
- * ```js
- * const v = vec(16n)(0x3456n) // 0x13456n
- * const r = removeMsb(4n)(v) // 0x1456n
- * const r2 = removeMsb(24n)(v) // 0x1n
- * ```
- */
-export declare const removeMsb: (len: bigint) => (v: Vec) => Vec;
-/**
- * Extracts the most significant unsigned integer and removes it from the vector.
- *
- * @example
- *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
- * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
- * ```
- */
-export declare const popUintMsb: (len: bigint) => (v: Vec) => readonly [bigint, Vec];
-/**
- * Concat the given vectors of bits. The first vector is the least significant.
- *
- * @example
- *
- * ```js
- * const u8 = vec(8n)
- * const a = u8(0x45n) // 0x145n
- * const b = u8(0x89n) // 0x189n
- * const ab = concatLsb(a)(b) // 0x18945n
- * ```
- */
-export declare const concatLsb: (a: Vec) => (b: Vec) => Vec;
-/**
- * Concat the given vectors of bits. The first vector is the most significant.
- *
- * @example
- *
- * ```js
- * const u8 = vec(8n)
- * const a = u8(0x45n) // 0x145n
- * const b = u8(0x89n) // 0x189n
- * const ab = concatMsb(a)(b) // 0x14589n
- * ```
+ * @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 declare const concatMsb: (b: Vec) => (a: Vec) => Vec;
-export {};
+export declare const u8List: ({ popFront }: BitOrder) => (v: Vec) => Thunk<number>;

package/types/bit_vec/module.f.js

@@ -1,5 +1,6 @@
-import { log2 } from "../bigint/module.f.js";
+import { log2, mask } from "../bigint/module.f.js";
 import { flip } from "../function/module.f.js";
+import { fold } from "../list/module.f.js";
 /**
  * An empty vector of bits.
  */
@@ -27,7 +28,10 @@ export const vec = (len) => {
     const mask = stop - 1n;
     return data => stop | (data & mask);
 };
-const mask = (len) => (1n << len) - 1n;
+/**
+ * Creates an 8 bit vector from an unsigned integer.
+ */
+export const vec8 = vec(8n);
 /**
  * Returns the unsigned integer of the given vector by removing a stop bit.
  *
@@ -40,128 +44,82 @@ const mask = (len) => (1n << len) - 1n;
  */
 export const uint = (v) => v ^ (1n << length(v));
 /**
- * Extract the least significant unsigned integer from the given vector.
+ * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
- * @example
+ * https://en.wikipedia.org/wiki/Bit_numbering#LSb_0_bit_numbering
  *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const result = uintLsb(4n)(vector); // result is 5n
- * const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
- * ```
+ * Usually associated with Little-Endian (LE) byte order.
  */
-export const uintLsb = (len) => {
-    const m = mask(len);
-    return v => {
-        const result = v & m;
-        return result === v ? uint(v) : result;
-    };
-};
-/**
- * Removes the first `len` least significant bits from the given vector.
- *
- * @example
- *
- * ```js
- * const v = vec(16n)(0x3456n) // 0x13456n
- * const r = removeLsb(4n)(v) // 0x1345n
- * const r2 = removeLsb(24n)(v) // 0x1n
- * ```
- */
-export const removeLsb = (len) => (v) => {
-    const r = v >> len;
-    return r === 0n ? empty : r;
-};
-/**
- * Extracts the least significant unsigned integer and removes it from the vector.
- *
- * @example
- *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
- * const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
- * ```
- */
-export const popUintLsb = (len) => {
-    const m = mask(len);
-    return v => {
-        const result = v & m;
-        return result === v ? [uint(v), empty] : [result, v >> len];
-    };
+export const lsb = {
+    front: len => {
+        const m = mask(len);
+        return v => {
+            const result = v & m;
+            return result === v ? uint(v) : result;
+        };
+    },
+    removeFront: len => v => {
+        const r = v >> len;
+        return r === 0n ? empty : r;
+    },
+    popFront: len => {
+        const m = mask(len);
+        return v => {
+            const result = v & m;
+            return result === v ? [uint(v), empty] : [result, v >> len];
+        };
+    },
+    concat: a => {
+        const aLen = length(a);
+        const m = mask(aLen);
+        return b => (b << aLen) | (a & m);
+    }
 };
 /**
- * Extract the most significant unsigned integer of the given `len` from the given vector.
+ * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
  *
- * @example
+ * https://en.wikipedia.org/wiki/Bit_numbering#MSb_0_bit_numbering
  *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const result = uintMsb(4n)(vector); // result is 0xFn
- * const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
- * ```
+ * Usually associated with Big-Endian (BE) byte order.
  */
-export const uintMsb = (len) => {
-    const m = mask(len);
-    return v => (v >> (length(v) - len)) & m;
+export const msb = {
+    front: len => {
+        const m = mask(len);
+        return v => (v >> (length(v) - len)) & m;
+    },
+    removeFront: len => v => vec(length(v) - len)(v),
+    popFront: len => {
+        const m = mask(len);
+        return v => {
+            const d = length(v) - len;
+            return [(v >> d) & m, vec(d)(v)];
+        };
+    },
+    concat: flip(lsb.concat)
 };
+const appendU8 = ({ concat }) => (u8) => (a) => concat(a)(vec8(BigInt(u8)));
 /**
- * Removes the first `len` most significant bits from the given vector.
- *
- * @example
+ * Converts a list of unsigned 8-bit integers to a bit vector.
  *
- * ```js
- * const v = vec(16n)(0x3456n) // 0x13456n
- * const r = removeMsb(4n)(v) // 0x1456n
- * const r2 = removeMsb(24n)(v) // 0x1n
- * ```
+ * @param bo The bit order for the conversion
+ * @param list The list of unsigned 8-bit integers to be converted.
+ * @returns The resulting vector based on the provided bit order.
  */
-export const removeMsb = (len) => (v) => vec(length(v) - len)(v);
+export const u8ListToVec = (bo) => fold(appendU8(bo))(empty);
 /**
- * Extracts the most significant unsigned integer and removes it from the vector.
+ * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
- * @example
- *
- * ```js
- * const vector = vec(8n)(0xF5n) // 0x1F5n
- * const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
- * const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
- * ```
+ * @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 popUintMsb = (len) => {
-    const m = mask(len);
-    return v => {
-        const d = length(v) - len;
-        return [(v >> d) & m, vec(d)(v)];
+export const u8List = ({ popFront }) => {
+    const f = (v) => () => {
+        if (v === empty) {
+            return null;
+        }
+        const [first, tail] = popFront(8n)(v);
+        return { first: Number(first), tail: f(tail) };
     };
+    return f;
 };
-/**
- * Concat the given vectors of bits. The first vector is the least significant.
- *
- * @example
- *
- * ```js
- * const u8 = vec(8n)
- * const a = u8(0x45n) // 0x145n
- * const b = u8(0x89n) // 0x189n
- * const ab = concatLsb(a)(b) // 0x18945n
- * ```
- */
-export const concatLsb = (a) => {
-    const aLen = length(a);
-    const m = mask(aLen);
-    return b => (b << aLen) | (a & m);
-};
-/**
- * Concat the given vectors of bits. The first vector is the most significant.
- *
- * @example
- *
- * ```js
- * const u8 = vec(8n)
- * const a = u8(0x45n) // 0x145n
- * const b = u8(0x89n) // 0x189n
- * const ab = concatMsb(a)(b) // 0x14589n
- * ```
- */
-export const concatMsb = flip(concatLsb);

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

@@ -2,14 +2,26 @@ declare const _default: {
     examples: {
         vec: () => void;
         uint: () => void;
-        uintLsb: () => void;
-        uintMsb: () => void;
-        popUintLsb: () => void;
-        popUintMsb: () => void;
-        concatLsb: () => void;
-        concatMsb: () => void;
-        removeLsb: () => void;
-        removeMsb: () => void;
+        front: () => void;
+        removeFront: () => void;
+        popFront: () => void;
+        concat: () => void;
+    };
+    front: {
+        lsbf: () => void;
+        msbf: () => void;
+    };
+    popFront: {
+        lsbm: () => void;
+        msbm: () => void;
+    };
+    removeFront: {
+        lsbm: () => void;
+        msbm: () => void;
+    };
+    concat: {
+        lsbm: () => void;
+        msbm: () => void;
     };
     uintLsb: () => void;
     uintSmall: () => void;