functionalscript 0.3.7 → 0.3.8

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;

package/types/bit_vec/test.f.js

@@ -1,4 +1,73 @@
-import { empty, vec, length, concatLsb, uintLsb, uintMsb, removeLsb, concatMsb, removeMsb, uint, popUintLsb, popUintMsb } from "./module.f.js";
+import { empty, vec, length, uint, lsb, msb } from "./module.f.js";
+const frontTest = (e) => (r0) => (r1) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    if (vector !== 0x1f5n) {
+        throw vector;
+    }
+    const result = e.front(4n)(vector);
+    if (result !== r0) {
+        throw result;
+    }
+    const result2 = e.front(16n)(vector);
+    if (result2 !== r1) {
+        throw result2;
+    }
+};
+const popFront = (e) => ([r00, r01]) => ([r10, r11]) => () => {
+    const vector = vec(8n)(0xf5n); // 0x1F5n
+    const [result, rest] = e.popFront(4n)(vector);
+    if (result !== r00) {
+        throw result;
+    }
+    if (rest !== r01) {
+        throw rest;
+    }
+    const [result2, rest2] = e.popFront(16n)(vector);
+    if (result2 !== r10) {
+        throw result2;
+    }
+    if (rest2 !== r11) {
+        throw rest2;
+    }
+};
+const removeFront = (e) => (r0) => (r1) => () => {
+    const v = vec(16n)(0x3456n); // 0x13456n
+    if (v !== 0x13456n) {
+        throw v;
+    }
+    const r = e.removeFront(4n)(v);
+    if (r !== r0) {
+        throw r;
+    }
+    const r2 = e.removeFront(24n)(v);
+    if (r2 !== r1) {
+        throw r2;
+    }
+};
+const concat = (e) => (r) => () => {
+    const u8 = vec(8n);
+    const a = u8(0x45n); // 0x145n
+    if (a !== 0x145n) {
+        throw a;
+    }
+    const b = u8(0x89n); // 0x189n
+    if (b !== 0x189n) {
+        throw b;
+    }
+    const ab = e.concat(a)(b); // 0x18945n
+    if (ab !== r) {
+        throw ab;
+    }
+};
+const assertEq = (a, b) => {
+    if (a !== b) {
+        throw [a, b];
+    }
+};
+const assertEq2 = ([a0, a1], [b0, b1]) => {
+    assertEq(a0, b0);
+    assertEq(a1, b1);
+};
 export default {
     examples: {
         vec: () => {
@@ -22,130 +91,54 @@ export default {
                 throw result;
             }
         },
-        uintLsb: () => {
+        front: () => {
             const vector = vec(8n)(0xf5n); // 0x1F5n
-            if (vector !== 0x1f5n) {
-                throw vector;
-            }
-            const result = uintLsb(4n)(vector); // result is 5n
-            if (result !== 5n) {
-                throw result;
-            }
-            const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
-            if (result2 !== 0xf5n) {
-                throw result2;
-            }
+            assertEq(lsb.front(4n)(vector), 5n);
+            assertEq(lsb.front(16n)(vector), 0xf5n);
+            assertEq(msb.front(4n)(vector), 0xfn);
+            assertEq(msb.front(16n)(vector), 0xf500n);
         },
-        uintMsb: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
-            if (vector !== 0x1f5n) {
-                throw vector;
-            }
-            const result = uintMsb(4n)(vector); // result is 0xFn
-            if (result !== 0xfn) {
-                throw result;
-            }
-            const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
-            if (result2 !== 0xf500n) {
-                throw result2;
-            }
-        },
-        popUintLsb: () => {
-            const vector = vec(8n)(0xf5n); // 0x1F5n
-            const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
-            if (result !== 5n) {
-                throw result;
-            }
-            if (rest !== 0x1fn) {
-                throw rest;
-            }
-            const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
-            if (result2 !== 0xf5n) {
-                throw result2;
-            }
-            if (rest2 !== 1n) {
-                throw rest2;
-            }
+        removeFront: () => {
+            const v = vec(16n)(0x3456n); // 0x13456n
+            assertEq(lsb.removeFront(4n)(v), 0x1345n);
+            assertEq(lsb.removeFront(24n)(v), 0x1n);
+            assertEq(msb.removeFront(4n)(v), 0x1456n);
+            assertEq(msb.removeFront(24n)(v), 0x1n);
         },
-        popUintMsb: () => {
+        popFront: () => {
             const vector = vec(8n)(0xf5n); // 0x1F5n
-            const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
-            if (result !== 0xfn) {
-                throw result;
-            }
-            if (rest !== 0x15n) {
-                throw rest;
-            }
-            const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
-            if (result2 !== 0xf500n) {
-                throw result2;
-            }
-            if (rest2 !== 1n) {
-                throw rest2;
-            }
-        },
-        concatLsb: () => {
-            const u8 = vec(8n);
-            const a = u8(0x45n); // 0x145n
-            if (a !== 0x145n) {
-                throw a;
-            }
-            const b = u8(0x89n); // 0x189n
-            if (b !== 0x189n) {
-                throw b;
-            }
-            const ab = concatLsb(a)(b); // 0x18945n
-            if (ab !== 0x18945n) {
-                throw ab;
-            }
+            assertEq2(lsb.popFront(4n)(vector), [5n, 0x1fn]);
+            assertEq2(lsb.popFront(16n)(vector), [0xf5n, 1n]);
+            assertEq2(msb.popFront(4n)(vector), [0xfn, 0x15n]);
+            assertEq2(msb.popFront(16n)(vector), [0xf500n, 1n]);
         },
-        concatMsb: () => {
+        concat: () => {
             const u8 = vec(8n);
             const a = u8(0x45n); // 0x145n
-            if (a !== 0x145n) {
-                throw a;
-            }
             const b = u8(0x89n); // 0x189n
-            if (b !== 0x189n) {
-                throw b;
-            }
-            const ab = concatMsb(a)(b); // 0x14589n
-            if (ab !== 0x14589n) {
-                throw ab;
-            }
-        },
-        removeLsb: () => {
-            const v = vec(16n)(0x3456n); // 0x13456n
-            if (v !== 0x13456n) {
-                throw v;
-            }
-            const r = removeLsb(4n)(v); // 0x1345n
-            if (r !== 0x1345n) {
-                throw r;
-            }
-            const r2 = removeLsb(24n)(v); // 0x1n
-            if (r2 !== 0x1n) {
-                throw r2;
-            }
-        },
-        removeMsb: () => {
-            const v = vec(16n)(0x3456n); // 0x13456n
-            if (v !== 0x13456n) {
-                throw v;
-            }
-            const r = removeMsb(4n)(v); // 0x1456n
-            if (r !== 0x1456n) {
-                throw r;
-            }
-            const r2 = removeMsb(24n)(v); // 0x1n
-            if (r2 !== 0x1n) {
-                throw r2;
-            }
+            assertEq(lsb.concat(a)(b), 0x18945n);
+            assertEq(msb.concat(a)(b), 0x14589n);
         }
     },
+    front: {
+        lsbf: frontTest(lsb)(5n)(0xf5n),
+        msbf: frontTest(msb)(0xfn)(0xf500n),
+    },
+    popFront: {
+        lsbm: popFront(lsb)([5n, 0x1fn])([0xf5n, 1n]),
+        msbm: popFront(msb)([0xfn, 0x15n])([0xf500n, 1n]),
+    },
+    removeFront: {
+        lsbm: removeFront(lsb)(0x1345n)(0x1n),
+        msbm: removeFront(msb)(0x1456n)(0x1n),
+    },
+    concat: {
+        lsbm: concat(lsb)(0x18945n),
+        msbm: concat(msb)(0x14589n),
+    },
     uintLsb: () => {
         const vector = 117n;
-        const extract3Bits = uintLsb(3n);
+        const extract3Bits = lsb.front(3n);
         const result = extract3Bits(vector); // result is 0b101n (5n)
         if (result !== 5n) {
             throw result;
@@ -153,7 +146,7 @@ export default {
     },
     uintSmall: () => {
         const vector = 3n;
-        const extract3Bits = uintLsb(3n)(vector);
+        const extract3Bits = lsb.front(3n)(vector);
         if (extract3Bits !== 1n) {
             throw extract3Bits;
         }
@@ -179,7 +172,7 @@ export default {
         if (length(v) !== 8n) {
             throw 'len';
         }
-        const u = uintLsb(8n)(v);
+        const u = lsb.front(8n)(v);
         if (u !== 0xfen) {
             throw v;
         }
@@ -188,7 +181,7 @@ export default {
         const vec8 = vec(8n);
         const a = vec8(0x345n);
         const b = vec8(0x789n);
-        const ab = concatLsb(a)(b);
+        const ab = lsb.concat(a)(b);
         if (ab !== 0x18945n) {
             throw ab;
         }
@@ -202,7 +195,7 @@ export default {
         if (v !== 0x32345n) {
             throw v.toString(16);
         }
-        const r = removeLsb(9n)(v);
+        const r = lsb.removeFront(9n)(v);
         if (r !== 0x191n) {
             throw r.toString(16);
         }

package/types/btree/find/test.f.js

@@ -1,9 +1,7 @@
 import * as _ from "./module.f.js";
 import * as list from "../../list/module.f.js";
 import * as json from "../../../json/module.f.js";
-import * as o from "../../object/module.f.js";
-const { sort } = o;
-import * as btree from "../types/module.f.js";
+import { sort } from "../../object/module.f.js";
 import * as string from "../../string/module.f.js";
 const { cmp } = string;
 import * as s from "../set/module.f.js";
@@ -13,8 +11,9 @@ const str = r => jsonStr(list.toArray(list.map((x) => x[0])(r)));
 const find = i => m => str(_.find(cmp(i))(m));
 const test = () => {
     let _map = ['1'];
-    for (let i = 2; i <= 10; i++)
+    for (let i = 2; i <= 10; i++) {
         _map = set(_map)((i * i).toString());
+    }
     {
         const s = jsonStr(_map);
         if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') {

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

@@ -1,4 +1,4 @@
-import * as list from '../list/module.f.ts';
-import * as _ from './types/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type * as _ from './types/module.f.ts';
 export declare const empty: null;
-export declare const values: <T>(tree: _.Tree<T>) => list.List<T>;
+export declare const values: <T>(tree: _.Tree<T>) => List<T>;

package/types/btree/module.f.js

@@ -1,8 +1,5 @@
-import * as list from "../list/module.f.js";
-const { flat } = list;
-import * as n from "../nullable/module.f.js";
-const { map } = n;
-import * as _ from "./types/module.f.js";
+import { flat } from "../list/module.f.js";
+import { map } from "../nullable/module.f.js";
 const nodeValues = node => () => {
     switch (node.length) {
         case 1:

package/types/btree/remove/test.f.js

@@ -1,13 +1,12 @@
 import * as _ from "./module.f.js";
-import * as BTree from "../types/module.f.js";
 import * as s from "../set/module.f.js";
 import * as str from "../../string/module.f.js";
 const { cmp } = str;
 import * as json from "../../../json/module.f.js";
 import * as o from "../../object/module.f.js";
 const { sort } = o;
-const set = node => value => s.set(cmp(value))(() => value)(node);
-const remove = node => value => _.nodeRemove(cmp(value))(node);
+const set = (node) => (value) => s.set(cmp(value))(() => value)(node);
+const remove = (node) => (value) => _.nodeRemove(cmp(value))(node);
 const jsonStr = json.stringify(sort);
 const test = () => {
     let _map = ['1'];

package/types/btree/set/test.f.js

@@ -1,11 +1,8 @@
 import * as _ from "./module.f.js";
-import * as BTree from "../types/module.f.js";
-import * as s from "../../string/module.f.js";
-const { cmp } = s;
+import { cmp } from "../../string/module.f.js";
 import * as json from "../../../json/module.f.js";
-import * as o from "../../object/module.f.js";
-const { sort } = o;
-const set = node => value => _.set(cmp(value))(() => value)(node);
+import { sort } from "../../object/module.f.js";
+const set = (node) => (value) => _.set(cmp(value))(() => value)(node);
 const jsonStr = json.stringify(sort);
 const test = [
     () => {

package/types/btree/test.f.js

@@ -1,4 +1,3 @@
-import * as BTree from "./types/module.f.js";
 import * as _ from "./module.f.js";
 const { values } = _;
 import * as json from "../../json/module.f.js";

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

@@ -1,5 +1,6 @@
-type Array1<T> = readonly [T];
-type Array2<T> = readonly [T, T];
+export type Array1<T> = readonly [T];
+export type Array2<T> = readonly [T, T];
+export type Array3<T> = readonly [T, T, T];
 export type Leaf1<T> = Array1<T>;
 export type Leaf2<T> = Array2<T>;
 export type Branch3<T> = readonly [TNode<T>, T, TNode<T>];
@@ -8,4 +9,3 @@ export type TNode<T> = Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>;
 export type Tree<T> = TNode<T> | null;
 export type Branch1<T> = readonly [TNode<T>];
 export type Branch7<T> = readonly [...Branch5<T>, T, TNode<T>];
-export {};

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

@@ -1,5 +1,5 @@
-import * as RangeMap from '../range_map/module.f.ts';
-import * as SortedSet from '../sorted_set/module.f.ts';
+import type * as RangeMap from '../range_map/module.f.ts';
+import type * as SortedSet from '../sorted_set/module.f.ts';
 export type ByteSet = bigint;
 type Byte = number;
 export declare const has: (n: Byte) => (s: ByteSet) => boolean;

package/types/byte_set/module.f.js

@@ -1,6 +1,4 @@
 import { compose } from "../function/module.f.js";
-import * as RangeMap from "../range_map/module.f.js";
-import * as SortedSet from "../sorted_set/module.f.js";
 import * as list from "../list/module.f.js";
 const { reverse, countdown, flat, map } = list;
 export const has = n => s => ((s >> BigInt(n)) & 1n) === 1n;

package/types/function/compare/module.f.d.ts

@@ -1,4 +1,4 @@
-import * as Array from '../../array/module.f.ts';
+import type * as Array from '../../array/module.f.ts';
 export type Index3 = Array.Index3;
 export type Index5 = Array.Index5;
 type Array2<T> = Array.Array2<T>;

package/types/function/compare/module.f.js

@@ -1,4 +1,3 @@
-import * as Array from "../../array/module.f.js";
 export const index3 = cmp => value => (cmp(value) + 1);
 export const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0);

package/types/function/compare/test.f.js

@@ -1,5 +1,4 @@
-import * as _ from "./module.f.js";
-const { unsafeCmp } = _;
+import { unsafeCmp } from "./module.f.js";
 export default () => {
     const result = unsafeCmp(true)(false);
     if (result !== 1) {

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

@@ -24,5 +24,5 @@ type Fn<I, O> = {
 /**
  * Creates an `Fn` instance from a function, enabling chaining of transformations.
  */
-export declare const fn: <I, O>(f: (i: I) => O) => Fn<I, O>;
+export declare const fn: <I, O>(result: Func<I, O>) => Fn<I, O>;
 export {};