functionalscript 0.11.9 → 0.11.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.11.9",
+  "version": "0.11.10",
   "type": "module",
   "files": [
     "**/*.js",

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

@@ -162,6 +162,7 @@ export type BitOrder = {
      */
     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.
@@ -186,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.
  *

package/types/bit_vec/module.f.js

@@ -107,7 +107,7 @@ 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 bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }) => {
     const unpackPopFront = (len) => {
         const m = mask(len);
         const us = unpackSplit(len);
@@ -116,10 +116,17 @@ const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
             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 => {
@@ -140,8 +147,10 @@ const bo = ({ front, removeFront, concat, norm, uintCmp, unpackSplit }) => {
             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.
  *
@@ -158,17 +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 }),
     uintCmp: a => b => {
         const diff = a ^ b;
         return diff === 0n ? 0 : (a & (diff & -diff)) === 0n ? -1 : 1;
     },
-    unpackSplit: len => ({ uint }) => [uint, uint >> len]
+    unpackSplit: len => ({ uint }) => [uint, uint >> len],
+    unpackConcatUint: lsbUnpackConcatUint
 });
 /**
  * Implements operations for handling vectors in a most-significant-bit (MSb) first order.
@@ -189,11 +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) }),
     uintCmp: cmp,
-    unpackSplit: len => ({ length, uint }) => [uint >> (length - len), uint]
+    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.
  *
@@ -201,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) {
@@ -218,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.