functionalscript 0.11.8 → 0.11.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.8",
+  "version": "0.11.10",
   "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

@@ -153,6 +153,16 @@ export type BitOrder = {
     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];
+    readonly unpackConcat: (a: Unpacked) => (b: Unpacked) => Unpacked;
 };
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
@@ -177,7 +187,7 @@ export declare const msb: BitOrder;
  * @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 u8ListToVec: ({ concat }: BitOrder) => (list: List<number>) => Vec;
+export declare const u8ListToVec: ({ unpackConcat }: BitOrder) => (list: List<number>) => Vec;
 /**
  * Converts a bit vector to a list of unsigned 8-bit integers based on the provided bit order.
  *
@@ -185,7 +195,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: ({ unpackPopFront }: 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.
  */
@@ -195,14 +205,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

@@ -107,18 +107,26 @@ const op = (norm) => (op) => ap => bp => {
     const { a, b } = norm(au)(bu)(len);
     return vec(len)(op(a)(b));
 };
-const bo = ({ front, removeFront, concat, rawPopFront, norm }) => {
+const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
     const unpackPopFront = (len) => {
         const m = mask(len);
+        const us = unpackSplit(len);
         return (v) => {
-            const [uint, rest] = rawPopFront(len)(v);
-            return [uint & m, rest];
+            const [uint, rest] = us(v);
+            return [uint & m, { length: v.length - len, uint: rest }];
         };
     };
+    const unpackConcat = (a) => (b) => ({
+        length: a.length + b.length, uint: unpackConcatUint(a)(b)
+    });
     return {
         front,
         removeFront,
-        concat,
+        concat: a => b => {
+            const au = unpack(a);
+            const bu = unpack(b);
+            return pack(unpackConcat(au)(bu));
+        },
         xor: op(norm)(xor),
         unpackPopFront,
         popFront: len => {
@@ -129,8 +137,20 @@ const bo = ({ front, removeFront, concat, rawPopFront, norm }) => {
             };
         },
         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,
+        unpackConcat,
     };
 };
+const lsbUnpackConcatUint = ({ uint: a, length }) => ({ uint: b }) => (b << length) | a;
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.
  *
@@ -147,13 +167,13 @@ export const lsb = bo({
         const { length, uint } = unpack(v);
         return 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);
-    },
     norm: ({ uint: a }) => ({ uint: b }) => () => ({ a, b }),
-    rawPopFront: len => ({ length, uint }) => [uint, { length: length - len, uint: uint >> len }]
+    uintCmp: a => b => {
+        const diff = a ^ b;
+        return diff === 0n ? 0 : (a & (diff & -diff)) === 0n ? -1 : 1;
+    },
+    unpackSplit: len => ({ uint }) => [uint, uint >> len],
+    unpackConcatUint: lsbUnpackConcatUint
 });
 /**
  * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
@@ -174,13 +194,12 @@ export const msb = bo({
         const { length, uint } = unpack(v);
         return vec(length - len)(uint);
     },
-    concat: flip(lsb.concat),
     norm: ({ length: al, uint: a }) => ({ length: bl, uint: b }) => len => ({ a: a << (len - al), b: b << (len - bl) }),
-    rawPopFront: len => ({ length, uint }) => {
-        const d = length - len;
-        return [uint >> d, { length: d, uint }];
-    }
+    uintCmp: cmp,
+    unpackSplit: len => ({ length, uint }) => [uint >> (length - len), uint],
+    unpackConcatUint: flip(lsbUnpackConcatUint),
 });
+const unpackEmpty = { length: 0n, uint: 0n };
 /**
  * Converts a list of unsigned 8-bit integers to a bit vector using the provided bit order.
  *
@@ -188,16 +207,10 @@ export const msb = bo({
  * @param list The list of unsigned 8-bit integers to be converted.
  * @returns The resulting vector based on the provided bit order.
  */
-export const u8ListToVec = ({ concat }) => (list) => {
-    // much faster than: `fold(appendU8(bo))(empty)(list)`
-    // where `appendU8` is defined as
-    // ```
-    // const appendU8 = ({ concat }: BitOrder) => (u8: number) => (a: Vec) =>
-    //    concat(a)(vec8(BigInt(u8)))
-    // ```
+export const u8ListToVec = ({ unpackConcat }) => (list) => {
     let result = [];
     for (const b of iterable(list)) {
-        let v = vec8(BigInt(b));
+        let v = { length: 8n, uint: BigInt(b) };
         let i = 0;
         while (true) {
             if (result.length <= i) {
@@ -205,16 +218,16 @@ export const u8ListToVec = ({ concat }) => (list) => {
                 break;
             }
             const old = result[i];
-            if (old === empty) {
+            if (old.length === 0n) {
                 result = result.toSpliced(i, 1, v);
                 break;
             }
-            result = result.toSpliced(i, 1, empty);
-            v = concat(old)(v);
+            result = result.toSpliced(i, 1, unpackEmpty);
+            v = unpackConcat(old)(v);
             i++;
         }
     }
-    return result.reduce((p, c) => concat(c)(p), empty);
+    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.
@@ -223,16 +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 = ({ unpackPopFront }) => {
-    const pf = unpackPopFront(8n);
-    const f = (u) => () => {
-        if (u.length <= 0n) {
-            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] = pf(u);
-        return { first: Number(first), tail: f(tail) };
     };
-    return v => f(unpack(v));
+    return f([unpack(v), undefined]);
 };
 /**
  * Concatenates a list of vectors using the provided bit order.
@@ -243,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 } = msb.norm(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,6 +37,7 @@ declare const _default: {
     lsbXor: () => void;
     msbXor: () => void;
     repeat: () => void;
+    lsbCmp: () => void;
     msbCmp: () => void;
     u8ListToVec: () => () => void;
     u8ListUnaligned: () => void;

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, msbCmp, u8ListToVec, u8List } from "./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
@@ -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}`;
             }
@@ -451,7 +465,7 @@ export default {
             const m = u8List(msb)(x);
             const y = toArray(m);
             if (y.length !== 131_071) {
-                throw y.length;
+                throw `y.lenght: ${y.length}`;
             }
         };
     },
@@ -459,7 +473,7 @@ export default {
         const x = vec(9n)(0x83n);
         const a = toArray(u8List(msb)(x));
         if (a.length !== 2) {
-            throw a;
+            throw `a.lenght: ${a.length}`;
         }
         const [a0, a1] = a;
         if (a0 !== 0x41) {

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