functionalscript 0.3.7 → 0.3.8

package/text/utf8/test.f.js

@@ -1,67 +1,66 @@
-import * as encoding from "./module.f.js";
+import { toCodePointList, fromCodePointList } from "./module.f.js";
 import * as json from "../../json/module.f.js";
-import * as o from "../../types/object/module.f.js";
-const { sort } = o;
-import * as list from "../../types/list/module.f.js";
+import { sort } from "../../types/object/module.f.js";
+import { toArray } from "../../types/list/module.f.js";
 const stringify = json.stringify(sort);
 export default {
     toCodePoint: [
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([-1, 256])));
+            const result = stringify(toArray(toCodePointList([-1, 256])));
             if (result !== '[2147483648,2147483648]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([128, 193, 245, 255])));
+            const result = stringify(toArray(toCodePointList([128, 193, 245, 255])));
             if (result !== '[-2147483520,-2147483455,-2147483403,-2147483393]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([0, 1, 127])));
+            const result = stringify(toArray(toCodePointList([0, 1, 127])));
             if (result !== '[0,1,127]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([194, 128, 194, 169, 223, 191])));
+            const result = stringify(toArray(toCodePointList([194, 128, 194, 169, 223, 191])));
             if (result !== '[128,169,2047]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([194, 194, 127, 194, 192, 194])));
+            const result = stringify(toArray(toCodePointList([194, 194, 127, 194, 192, 194])));
             if (result !== '[-2147483454,-2147483454,127,-2147483454,-2147483456,-2147483454]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
+            const result = stringify(toArray(toCodePointList([224, 160, 128, 224, 160, 129, 239, 191, 191])));
             if (result !== '[2048,2049,65535]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([224, 224, 160, 127, 239, 191])));
+            const result = stringify(toArray(toCodePointList([224, 224, 160, 127, 239, 191])));
             if (result !== '[-2147483424,-2147482592,127,-2147481601]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
+            const result = stringify(toArray(toCodePointList([240, 144, 128, 128, 240, 144, 128, 129, 244, 143, 191, 191])));
             if (result !== '[65536,65537,1114111]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 240, 160, 127, 244, 191])));
+            const result = stringify(toArray(toCodePointList([240, 240, 160, 127, 244, 191])));
             if (result !== '[-2147483408,-2147483104,127,-2147482817]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.toCodePointList([240, 160, 160, 244, 160, 160])));
+            const result = stringify(toArray(toCodePointList([240, 160, 160, 244, 160, 160])));
             if (result !== '[-2147448800,-2147432416]') {
                 throw result;
             }
@@ -69,67 +68,67 @@ export default {
     ],
     fromCodePointList: [
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0, 1, 0x7F])));
+            const result = stringify(toArray(fromCodePointList([0, 1, 0x7F])));
             if (result !== '[0,1,127]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x80])));
+            const result = stringify(toArray(fromCodePointList([0x80])));
             if (result !== '[194,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xa9])));
+            const result = stringify(toArray(fromCodePointList([0xa9])));
             if (result !== '[194,169]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x7ff])));
+            const result = stringify(toArray(fromCodePointList([0x7ff])));
             if (result !== '[223,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x800])));
+            const result = stringify(toArray(fromCodePointList([0x800])));
             if (result !== '[224,160,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x801])));
+            const result = stringify(toArray(fromCodePointList([0x801])));
             if (result !== '[224,160,129]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0xffff])));
+            const result = stringify(toArray(fromCodePointList([0xffff])));
             if (result !== '[239,191,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10000])));
+            const result = stringify(toArray(fromCodePointList([0x10000])));
             if (result !== '[240,144,128,128]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10001])));
+            const result = stringify(toArray(fromCodePointList([0x10001])));
             if (result !== '[240,144,128,129]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x10FFFF])));
+            const result = stringify(toArray(fromCodePointList([0x10FFFF])));
             if (result !== '[244,143,191,191]') {
                 throw result;
             }
         },
         () => {
-            const result = stringify(list.toArray(encoding.fromCodePointList([0x110000, 2147483648])));
+            const result = stringify(toArray(fromCodePointList([0x110000, 2147483648])));
             if (result !== '[2147483648,2147483648]') {
                 throw result;
             }
@@ -137,36 +136,36 @@ export default {
     ],
     toFrom: [
         () => {
-            const codePointList = encoding.toCodePointList([128, 193, 245, 255]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([128, 193, 245, 255]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[128,193,245,255]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([194, 194, 127, 194, 192, 194]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([194, 194, 127, 194, 192, 194]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[194,194,127,194,192,194]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([224, 224, 160, 127, 239, 191]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([224, 224, 160, 127, 239, 191]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[224,224,160,127,239,191]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([240, 240, 160, 127, 244, 191]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([240, 240, 160, 127, 244, 191]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[240,240,160,127,244,191]') {
                 throw result;
             }
         },
         () => {
-            const codePointList = encoding.toCodePointList([240, 160, 160, 244, 160, 160]);
-            const result = stringify(list.toArray(encoding.fromCodePointList(codePointList)));
+            const codePointList = toCodePointList([240, 160, 160, 244, 160, 160]);
+            const result = stringify(toArray(fromCodePointList(codePointList)));
             if (result !== '[240,160,160,244,160,160]') {
                 throw result;
             }

package/types/bigfloat/module.f.js

@@ -46,7 +46,7 @@ const round53 = ([[m, e], r]) => {
     }
     return multiply([m53 + o54, e53])(s);
 };
-export const decToBin = dec => {
+export const decToBin = (dec) => {
     if (dec[0] === 0n) {
         return [0n, 0];
     }

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

@@ -1,8 +1,8 @@
 import * as compare from '../function/compare/module.f.ts';
 import type * as Operator from '../function/operator/module.f.ts';
 import { type List } from '../list/module.f.ts';
-type Unary = Operator.Unary<bigint, bigint>;
-type Reduce = Operator.Reduce<bigint>;
+export type Unary = Operator.Unary<bigint, bigint>;
+export type Reduce = Operator.Reduce<bigint>;
 export declare const addition: Reduce;
 export declare const sum: (input: List<bigint>) => bigint;
 export declare const abs: Unary;
@@ -44,8 +44,20 @@ export declare const log2: (v: bigint) => bigint;
  * @returns The bit length of the input BigInt.
  *
  * @remark
- * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
- * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
+ * The function uses the `log2` function to calculate the position of the most significant bit (MSB)
+ * and adds `1n` to account for the MSB itself. For negative numbers, the absolute value is used.
  */
 export declare const bitLength: (v: bigint) => bigint;
-export {};
+/**
+ * Generates a bitmask with the specified number of bits set to 1.
+ *
+ * @param len - The number of bits to set in the mask. Must be a non-negative integer.
+ * @returns A bigint representing the bitmask, where the least significant `len` bits are 1.
+ *
+ * @example
+ *
+ * ```js
+ * const result = mask(3n) // 7n
+ * ```
+ */
+export declare const mask: (len: bigint) => bigint;

package/types/bigint/module.f.js

@@ -4,8 +4,8 @@ import { reduce } from "../list/module.f.js";
 export const addition = a => b => a + b;
 export const sum = reduce(addition)(0n);
 export const abs = a => a >= 0 ? a : -a;
-export const sign = a => unsafeCmp(a)(0n);
-export const serialize = a => `${a}n`;
+export const sign = (a) => unsafeCmp(a)(0n);
+export const serialize = (a) => `${a}n`;
 /**
  * Calculates the base-2 logarithm (floor).
  *
@@ -25,6 +25,8 @@ export const serialize = a => `${a}n`;
  *    determining the exact value of the logarithm.
  */
 export const log2 = (v) => {
+    // TODO: use step 32 and `Math.clz32()` at the end.
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math/clz32
     if (v <= 0n) {
         return -1n;
     }
@@ -69,8 +71,8 @@ export const log2 = (v) => {
  * @returns The bit length of the input BigInt.
  *
  * @remark
- * The function uses the `log2` function to calculate the position of the most significant bit(MSB)
- * and adds `1n` to account for the MSB itself.For negative numbers, the absolute value is used.
+ * The function uses the `log2` function to calculate the position of the most significant bit (MSB)
+ * and adds `1n` to account for the MSB itself. For negative numbers, the absolute value is used.
  */
 export const bitLength = (v) => {
     if (v <= 0n) {
@@ -81,3 +83,16 @@ export const bitLength = (v) => {
     }
     return log2(v) + 1n;
 };
+/**
+ * Generates a bitmask with the specified number of bits set to 1.
+ *
+ * @param len - The number of bits to set in the mask. Must be a non-negative integer.
+ * @returns A bigint representing the bitmask, where the least significant `len` bits are 1.
+ *
+ * @example
+ *
+ * ```js
+ * const result = mask(3n) // 7n
+ * ```
+ */
+export const mask = (len) => (1n << len) - 1n;

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

@@ -1,4 +1,5 @@
 declare const _default: {
+    mask: () => void;
     sum: () => void;
     abs: (() => void)[];
     serialize: (() => void)[];

package/types/bigint/test.f.js

@@ -1,6 +1,11 @@
-import * as _ from "./module.f.js";
-const { sum, abs, serialize, log2, bitLength } = _;
+import { sum, abs, serialize, log2, bitLength, mask } from "./module.f.js";
 export default {
+    mask: () => {
+        const result = mask(3n); // 7n
+        if (result !== 7n) {
+            throw result;
+        }
+    },
     sum: () => {
         const result = sum([2n, 3n, 4n, 5n]);
         if (result !== 14n) {

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>;