functionalscript 0.11.7 → 0.11.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.7",
+  "version": "0.11.9",
   "type": "module",
   "files": [
     "**/*.js",
@@ -13,7 +13,7 @@
     "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "index": "node ./fjs/module.ts r ./dev/index/module.f.ts",
     "fst": "node ./fjs/module.ts t",
-    "fjs": "node ./fjs/module.ts",
+    "start": "node ./fjs/module.ts",
     "ci-update": "node ./fjs/module.ts r ./ci/module.f.ts",
     "update": "git clean -fdx && npm install && npm run index && npm run ci-update",
     "website": "node --experimental-strip-types ./fjs/module.ts r ./website/module.f.ts"

package/types/asn.1/module.f.js

@@ -1,5 +1,5 @@
 import { bitLength, max } from "../bigint/module.f.js";
-import { empty, isVec, length, listToVec, msb, msbCmp, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
+import { empty, isVec, length, listToVec, msb, uint, unpack, vec, vec8 } from "../bit_vec/module.f.js";
 import { identity } from "../function/module.f.js";
 import { encode as b128encode, decode as b128decode } from "../base128/module.f.js";
 const pop = msb.popFront;
@@ -163,7 +163,7 @@ export const decodeSequence = (v) => {
     return result;
 };
 /** Encodes a SET payload with canonical byte ordering. */
-export const encodeSet = genericEncodeSequence(v => v.toSorted((a, b) => msbCmp(a)(b)));
+export const encodeSet = genericEncodeSequence(v => v.toSorted((a, b) => msb.cmp(a)(b)));
 /** Decodes a SET payload. */
 export const decodeSet = decodeSequence;
 // encode

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,17 @@ 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;
+    /**
+     * Lexically compares two vectors.
+     *
+     * a < b => -1
+     * a > b => 1
+     * a === b => 0
+     */
+    readonly cmp: (a: Vec) => (b: Vec) => Sign;
+    readonly unpackSplit: (len: bigint) => (u: Unpacked) => readonly [bigint, bigint];
 };
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
@@ -177,7 +194,7 @@ export declare const u8ListToVec: ({ concat }: BitOrder) => (list: List<number>)
  * @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: ({ unpackSplit }: BitOrder) => (v: Vec) => Thunk<number>;
 /**
  * Concatenates a list of vectors using the provided bit order.
  */
@@ -187,13 +204,4 @@ export declare const listToVec: ({ concat }: BitOrder) => (list: List<Vec>) => V
  */
 export declare const repeat: Fold<bigint, Vec>;
 export declare const isVec: <T>(v: Vec | T) => v is Vec;
-/**
- * Lexically compares two vectors based on their unsigned integer values,
- * normalizing them to the same length. If the values are equal,
- * the shorter vector is considered smaller.
- *
- * a < b => -1
- * a > b => 1
- * 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 { entries, fold, iterable } 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,41 @@ const op = (norm) => (op) => ap => bp => {
     const { a, b } = norm(au)(bu)(len);
     return vec(len)(op(a)(b));
 };
+const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
+    const unpackPopFront = (len) => {
+        const m = mask(len);
+        const us = unpackSplit(len);
+        return (v) => {
+            const [uint, rest] = us(v);
+            return [uint & m, { length: v.length - len, uint: 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,
+        cmp: a => b => {
+            const au = unpack(a);
+            const bu = unpack(b);
+            const al = au.length;
+            const bl = bu.length;
+            const { a: aui, b: bui } = norm(au)(bu)(min(al)(bl));
+            const c = uintCmp(aui)(bui);
+            return c === 0 ? cmp(al)(bl) : c;
+        },
+        unpackSplit,
+    };
+};
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
@@ -116,7 +149,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 +158,18 @@ 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 }),
+    uintCmp: a => b => {
+        const diff = a ^ b;
+        return diff === 0n ? 0 : (a & (diff & -diff)) === 0n ? -1 : 1;
+    },
+    unpackSplit: len => ({ uint }) => [uint, uint >> len]
+});
 /**
  * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
  *
@@ -146,7 +177,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,17 +189,11 @@ 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)
-};
+    norm: ({ length: al, uint: a }) => ({ length: bl, uint: b }) => len => ({ a: a << (len - al), b: b << (len - bl) }),
+    uintCmp: cmp,
+    unpackSplit: len => ({ length, uint }) => [uint >> (length - len), uint]
+});
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -211,15 +236,30 @@ export const u8ListToVec = ({ concat }) => (list) => {
  * @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) {
-            return null;
+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],
+            ];
         }
-        const [first, tail] = popFront(8n)(v);
-        return { first: Number(first), tail: f(tail) };
     };
-    return f;
+    return f([unpack(v), undefined]);
 };
 /**
  * Concatenates a list of vectors using the provided bit order.
@@ -230,21 +270,3 @@ export const listToVec = ({ concat }) => fold(flip(concat))(empty);
  */
 export const repeat = mRepeat({ identity: empty, operation: lsb.concat });
 export const isVec = (v) => typeof v === 'bigint';
-/**
- * Lexically compares two vectors based on their unsigned integer values,
- * normalizing them to the same length. If the values are equal,
- * the shorter vector is considered smaller.
- *
- * a < b => -1
- * a > b => 1
- * a === b => 0
- */
-export const msbCmp = (av) => (bv) => {
-    const au = unpack(av);
-    const bu = unpack(bv);
-    const al = au.length;
-    const bl = bu.length;
-    const { a, b } = msbNorm(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

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

package/types/bit_vec/test.f.js

@@ -1,7 +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, u8ListToVec } from "./module.f.js";
-import { repeat as listRepeat } from "../list/module.f.js";
+import { length, empty, uint, vec, lsb, msb, repeat, vec8, 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
@@ -430,9 +430,23 @@ export default {
             throw 'repeat failed';
         }
     },
+    lsbCmp: () => {
+        const c = (a) => (b) => (r) => {
+            const result = lsb.cmp(a)(b);
+            if (result !== r) {
+                throw `result: ${result}, expected: ${r}`;
+            }
+        };
+        c(vec(4n)(0x5n))(vec(4n)(0x5n))(0); // [1,0,1,0] == [1,0,1,0]
+        c(vec(4n)(0x5n))(vec(4n)(0x6n))(1); // bit0: 1 > 0
+        c(vec(4n)(0x6n))(vec(4n)(0x5n))(-1); // bit0: 0 < 1
+        c(vec(4n)(0x5n))(vec(5n)(0x5n))(-1); // equal prefix, shorter is less
+        c(vec(5n)(0x5n))(vec(4n)(0x5n))(1); // equal prefix, longer is greater
+        c(vec(4n)(0x5n))(vec(5n)(0xan))(1); // bit0: 1 > 0
+    },
     msbCmp: () => {
         const c = (a) => (b) => (r) => {
-            const result = msbCmp(a)(b);
+            const result = msb.cmp(a)(b);
             if (result !== r) {
                 throw `result: ${result}, expected: ${r}`;
             }
@@ -447,5 +461,26 @@ export default {
     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.lenght: ${y.length}`;
+            }
+        };
+    },
+    u8ListUnaligned: () => {
+        const x = vec(9n)(0x83n);
+        const a = toArray(u8List(msb)(x));
+        if (a.length !== 2) {
+            throw `a.lenght: ${a.length}`;
+        }
+        const [a0, a1] = a;
+        if (a0 !== 0x41) {
+            throw `a0: ${a0.toString(16)}`;
+        }
+        if (a1 !== 0x80) {
+            throw `a1: ${a1.toString(16)}`;
+        }
     }
 };

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

@@ -4,7 +4,7 @@ type NotLazy<T> = Result<T> | Concat<T> | readonly T[];
 type Empty = null;
 export type Result<T> = Empty | NonEmpty<T>;
 export type Thunk<T> = () => List<T>;
-type NonEmpty<T> = {
+export type NonEmpty<T> = {
     readonly first: T;
     readonly tail: List<T>;
 };