functionalscript 0.12.9 → 0.12.10

package/package.json

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

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

@@ -163,6 +163,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;
+    readonly startsWith: (prefix: Vec) => (v: Vec) => boolean;
 };
 /**
  * Implements operations for handling vectors in a least-significant-bit (LSb) first order.

package/types/bit_vec/module.f.js

@@ -119,6 +119,13 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
     const unpackConcat = (a) => (b) => ({
         length: a.length + b.length, uint: unpackConcatUint(a)(b)
     });
+    const popFront = len => {
+        const f = unpackPopFront(len);
+        return v => {
+            const [uint, u] = f(unpack(v));
+            return [uint, pack(u)];
+        };
+    };
     return {
         front,
         removeFront,
@@ -129,13 +136,7 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
         },
         xor: op(norm)(xor),
         unpackPopFront,
-        popFront: len => {
-            const f = unpackPopFront(len);
-            return v => {
-                const [uint, u] = f(unpack(v));
-                return [uint, pack(u)];
-            };
-        },
+        popFront,
         norm,
         cmp: a => b => {
             const au = unpack(a);
@@ -148,6 +149,10 @@ const bo = ({ front, removeFront, norm, uintCmp, unpackSplit, unpackConcatUint }
         },
         unpackSplit,
         unpackConcat,
+        startsWith: prefix => {
+            const { length: n, uint: u } = unpack(prefix);
+            return v => length(v) < n ? false : popFront(n)(v)[0] === u;
+        }
     };
 };
 const lsbUnpackConcatUint = ({ uint: a, length }) => ({ uint: b }) => (b << length) | a;

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

@@ -39,6 +39,11 @@ declare const _default: {
     repeat: () => void;
     lsbCmp: () => void;
     msbCmp: () => void;
+    startsWith: {
+        lsb: () => void;
+        msb: () => void;
+        emptyVec: () => void;
+    };
     u8ListToVec: () => () => void;
     u8ListUnaligned: () => void;
     chunkList: {

package/types/bit_vec/test.f.js

@@ -458,6 +458,29 @@ export default {
         c(vec(5n)(0x5n))(vec(4n)(0x5n))(-1); // 0b00101 < 0b0101_
         c(vec(4n)(0x5n))(vec(5n)(0xan))(-1); // 0b0101_ < 0b01010
     },
+    startsWith: {
+        // vector 0xF5 = 0b1111_0101 (8 bits)
+        // LSB reads from the low end: bits 0-3 = 0101 = 0x5, bits 4-7 = 1111 = 0xF
+        lsb: () => {
+            const v = vec(8n)(0xf5n);
+            assertEq(lsb.startsWith(vec(4n)(0x5n))(v), true); // low nibble matches
+            assertEq(lsb.startsWith(vec(4n)(0xfn))(v), false); // low nibble doesn't match
+            assertEq(lsb.startsWith(v)(vec(4n)(0x5n)), false); // prefix longer than vector
+            assertEq(lsb.startsWith(empty)(v), true); // empty prefix always matches
+        },
+        // MSB reads from the high end: bits 0-3 = 1111 = 0xF, bits 4-7 = 0101 = 0x5
+        msb: () => {
+            const v = vec(8n)(0xf5n);
+            assertEq(msb.startsWith(vec(4n)(0xfn))(v), true); // high nibble matches
+            assertEq(msb.startsWith(vec(4n)(0x5n))(v), false); // high nibble doesn't match
+            assertEq(msb.startsWith(v)(vec(4n)(0xfn)), false); // prefix longer than vector
+            assertEq(msb.startsWith(empty)(v), true); // empty prefix always matches
+        },
+        emptyVec: () => {
+            assertEq(lsb.startsWith(empty)(empty), true);
+            assertEq(msb.startsWith(empty)(empty), true);
+        },
+    },
     u8ListToVec: () => {
         // 131_072 is too much for Bun
         const x = u8ListToVec(msb)(listRepeat(0x12)(131_071));

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

@@ -21,3 +21,4 @@ export declare const join: (_: string) => (input: List<string>) => string;
 export declare const concat: (input: List<string>) => string;
 export declare const repeat: (n: string) => (v: number) => string;
 export declare const cmp: (a: string) => (b: string) => Sign;
+export declare const splitAt: (p: number) => (v: string) => readonly [string, string];

package/types/string/module.f.js

@@ -24,3 +24,4 @@ export const join = compose(joinOp)(reduce);
 export const concat = reduce(concatOp);
 export const repeat = v => compose(listRepeat(v))(concat);
 export const cmp = uCmp;
+export const splitAt = (p) => (v) => [v.substring(0, p), v.substring(p)];

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

@@ -12,5 +12,12 @@ declare const _default: {
     };
     repeat: () => void;
     cmp: () => void;
+    splitAt: {
+        middle: () => void;
+        zero: () => void;
+        full: () => void;
+        beyond: () => void;
+        empty: () => void;
+    };
 };
 export default _default;

package/types/string/test.f.js

@@ -1,4 +1,4 @@
-import { join, concat, repeat, cmp } from "./module.f.js";
+import { join, concat, repeat, cmp, splitAt } from "./module.f.js";
 import { repeat as repeatList } from "../list/module.f.js";
 export default {
     example: () => {
@@ -67,5 +67,52 @@ export default {
         if (result !== -1) {
             throw result;
         }
+    },
+    splitAt: {
+        middle: () => {
+            const [a, b] = splitAt(3)('hello');
+            if (a !== 'hel') {
+                throw a;
+            }
+            if (b !== 'lo') {
+                throw b;
+            }
+        },
+        zero: () => {
+            const [a, b] = splitAt(0)('hello');
+            if (a !== '') {
+                throw a;
+            }
+            if (b !== 'hello') {
+                throw b;
+            }
+        },
+        full: () => {
+            const [a, b] = splitAt(5)('hello');
+            if (a !== 'hello') {
+                throw a;
+            }
+            if (b !== '') {
+                throw b;
+            }
+        },
+        beyond: () => {
+            const [a, b] = splitAt(10)('hello');
+            if (a !== 'hello') {
+                throw a;
+            }
+            if (b !== '') {
+                throw b;
+            }
+        },
+        empty: () => {
+            const [a, b] = splitAt(0)('');
+            if (a !== '') {
+                throw a;
+            }
+            if (b !== '') {
+                throw b;
+            }
+        },
     }
 };