functionalscript 0.12.9 → 0.13.0

package/ci/module.f.js

@@ -69,7 +69,7 @@ const node = (version) => (extra) => basicNode(version)([
 const findTgz = (v) => v === 'windows' ? '(Get-ChildItem *.tgz).FullName' : './*.tgz';
 const playwrightVersion = '1.58.2';
 const playwrightAndVersion = `playwright@${playwrightVersion}`;
-const rustToolchain = '1.94.1';
+const rustToolchain = '1.95.0';
 const toSteps = (m) => {
     const filter = (st) => m.flatMap((mt) => mt.type === st ? [mt.step] : []);
     const aptGet = m.flatMap(v => v.type === 'apt-get' ? [v.package] : []).join(' ');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.12.9",
+  "version": "0.13.0",
   "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/rtti/ts/module.f.d.ts

@@ -41,9 +41,10 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
     readonly [K in string]: Ts<E>;
 } : I extends readonly ['or', ...infer A extends readonly Type[]] ? Ts<A[number]> : never) : ConstTs<T>;
 /**
- * Converts an RTTI schema `Type` to its TypeScript type expression as a string.
+ * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *
  * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ * Pass `true` to emit mutable (non-`readonly`) types.
  *
  * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
  * will cause infinite recursion. Only acyclic schemas are supported.
@@ -53,14 +54,19 @@ export type Ts<T extends Type> = T extends () => infer I ? (I extends readonly [
  *
  * @example
  * ```ts
+ * const toTs = printer()
  * toTs(boolean)                    // 'boolean'
  * toTs(array(number))              // 'readonly(number)[]'
- * toTs(record(string))             // '{readonly[k in string]:string}'
+ * toTs(record(string))             // '{readonly[k:string]:string}'
  * toTs(or(string, number))         // 'string|number'
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
- * toTs({ x: string })              // '{readonly "x":string}'
+ * toTs({ x: string })              // '{readonly"x":string}'
+ *
+ * const toTsMut = printer(true)
+ * toTsMut(array(number))           // '(number)[]'
+ * toTsMut(record(string))          // '{[k:string]:string}'
  * ```
  */
-export declare const toTs: (rtti: Type) => string;
+export declare const printer: (mut?: true) => (rtti: Type) => string;

package/types/rtti/ts/module.f.js

@@ -7,15 +7,12 @@
  * The runtime `toTs` function mirrors `Ts<T>` at value level, returning a TypeScript
  * type expression string for a given RTTI schema.
  */
-import { primitive, tuple, struct, array, record, union } from "../../ts/module.f.js";
-/** Serialises a `Const` schema to its TypeScript type expression. */
-const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitive(rtti) :
-    rtti instanceof Array ? tuple(rtti.map(toTs)) :
-        struct(Object.entries(rtti).map(([k, v]) => [k, toTs(v)]));
+import { primitive, union, printer as tsPrinter } from "../../ts/module.f.js";
 /**
- * Converts an RTTI schema `Type` to its TypeScript type expression as a string.
+ * Creates a printer that converts an RTTI schema `Type` to its TypeScript type expression as a string.
  *
  * Mirrors the compile-time `Ts<T>` mapped type at runtime.
+ * Pass `true` to emit mutable (non-`readonly`) types.
  *
  * **Note:** recursive schemas (e.g. `const list = () => ['array', list] as const`)
  * will cause infinite recursion. Only acyclic schemas are supported.
@@ -25,26 +22,38 @@ const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitiv
  *
  * @example
  * ```ts
+ * const toTs = printer()
  * toTs(boolean)                    // 'boolean'
  * toTs(array(number))              // 'readonly(number)[]'
- * toTs(record(string))             // '{readonly[k in string]:string}'
+ * toTs(record(string))             // '{readonly[k:string]:string}'
  * toTs(or(string, number))         // 'string|number'
  * toTs(42)                         // '42'
  * toTs('hello')                    // '"hello"'
  * toTs([boolean, number])          // 'readonly[boolean,number]'
- * toTs({ x: string })              // '{readonly "x":string}'
+ * toTs({ x: string })              // '{readonly"x":string}'
+ *
+ * const toTsMut = printer(true)
+ * toTsMut(array(number))           // '(number)[]'
+ * toTsMut(record(string))          // '{[k:string]:string}'
  * ```
  */
-export const toTs = (rtti) => {
-    if (typeof rtti !== 'function') {
-        return constToTs(rtti);
-    }
-    const [tag, ...rest] = rtti();
-    switch (tag) {
-        case 'const': return constToTs(rest[0]);
-        case 'array': return array(toTs(rest[0]));
-        case 'record': return record(toTs(rest[0]));
-        case 'or': return union(rest.map(toTs));
-        default: return tag; // tag0: 'boolean' | 'number' | 'string' | 'bigint' | 'unknown'
-    }
+export const printer = (mut) => {
+    const { tuple, struct, array, record } = tsPrinter(mut);
+    const constToTs = (rtti) => typeof rtti !== 'object' || rtti === null ? primitive(rtti) :
+        rtti instanceof Array ? tuple(rtti.map(toTs)) :
+            struct(Object.entries(rtti).map(([k, v]) => [k, toTs(v)]));
+    const toTs = (rtti) => {
+        if (typeof rtti !== 'function') {
+            return constToTs(rtti);
+        }
+        const [tag, ...rest] = rtti();
+        switch (tag) {
+            case 'const': return constToTs(rest[0]);
+            case 'array': return array(toTs(rest[0]));
+            case 'record': return record(toTs(rest[0]));
+            case 'or': return union(rest.map(toTs));
+            default: return tag; // tag0: 'boolean' | 'number' | 'string' | 'bigint' | 'unknown'
+        }
+    };
+    return toTs;
 };

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

@@ -49,5 +49,12 @@ declare const _default: {
     };
     never: () => void;
     option: () => void;
+    mut: {
+        array: () => void;
+        nestedArray: () => void;
+        record: () => void;
+        tuple: () => void;
+        struct: () => void;
+    };
 };
 export default _default;

package/types/rtti/ts/test.f.js

@@ -1,5 +1,13 @@
-import { toTs } from "./module.f.js";
+import { printer } from "./module.f.js";
 import { boolean, number, string, bigint, unknown, array, record, or, option, never } from "../module.f.js";
+const toTs = printer();
+const toTsMut = printer(true);
+const eqMut = (rtti, expected) => {
+    const result = toTsMut(rtti);
+    if (result !== expected) {
+        throw `expected ${JSON.stringify(expected)}, got ${JSON.stringify(result)}`;
+    }
+};
 const eq = (rtti, expected) => {
     const result = toTs(rtti);
     if (result !== expected) {
@@ -21,8 +29,8 @@ export default {
             union: () => eq(array(or(number, string)), 'readonly(number|string)[]'),
         },
         record: {
-            primitive: () => eq(record(string), '{readonly[k in string]:string}'),
-            nested: () => eq(record(record(number)), '{readonly[k in string]:{readonly[k in string]:number}}'),
+            primitive: () => eq(record(string), '{readonly[k:string]:string}'),
+            nested: () => eq(record(record(number)), '{readonly[k:string]:{readonly[k:string]:number}}'),
         },
     },
     const: {
@@ -57,4 +65,11 @@ export default {
     },
     never: () => eq(never, 'never'),
     option: () => eq(option(number), 'number|undefined'),
+    mut: {
+        array: () => eqMut(array(number), '(number)[]'),
+        nestedArray: () => eqMut(array(array(boolean)), '((boolean)[])[]'),
+        record: () => eqMut(record(string), '{[k:string]:string}'),
+        tuple: () => eqMut([12, true], '[12,true]'),
+        struct: () => eqMut({ a: number, b: string }, '{"a":number,"b":string}'),
+    },
 };

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

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

@@ -1,8 +1,17 @@
 export type Equal<A, B> = (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2) ? true : false;
 export type Assert<T extends true> = T;
-export declare const tuple: (types: readonly string[]) => string;
-export declare const struct: (fields: readonly (readonly [string, string])[]) => string;
-export declare const array: (type: string) => string;
-export declare const record: (type: string) => string;
+/** Functions for emitting TypeScript type expression strings. */
+export type Printer = {
+    /** Emits a tuple type: `readonly[A, B]` or `[A, B]` when mutable. */
+    readonly tuple: (types: readonly string[]) => string;
+    /** Emits an object type with named fields: `{readonly"k":T}` or `{"k":T}` when mutable. */
+    readonly struct: (fields: readonly (readonly [string, string])[]) => string;
+    /** Emits an array type: `readonly(T)[]` or `(T)[]` when mutable. */
+    readonly array: (type: string) => string;
+    /** Emits an index-signature record type: `{readonly[k:string]:T}` or `{[k:string]:T}` when mutable. */
+    readonly record: (type: string) => string;
+};
+/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
+export declare const printer: (mut?: true) => Printer;
 export declare const primitive: (c: bigint | string | undefined | boolean | number | null) => string;
 export declare const union: (types: readonly string[]) => string;

package/types/ts/module.f.js

@@ -1,9 +1,15 @@
 const complex = (open, close) => (i) => `${open}${i.join(',')}${close}`;
-export const tuple = complex('readonly[', ']');
 const structX = complex('{', '}');
-export const struct = (fields) => structX(fields.map(([k, v]) => `readonly${JSON.stringify(k)}:${v}`));
-export const array = (type) => `readonly(${type})[]`;
-export const record = (type) => structX([`readonly[k in string]:${type}`]);
+/** Creates a `Printer`. Pass `true` to emit mutable (non-`readonly`) types. */
+export const printer = (mut) => {
+    const ro = mut ? '' : 'readonly';
+    return {
+        tuple: (mut ? complex('[', ']') : complex('readonly[', ']')),
+        struct: (fields) => structX(fields.map(([k, v]) => `${ro}${JSON.stringify(k)}:${v}`)),
+        array: (type) => `${ro}(${type})[]`,
+        record: (type) => structX([`${ro}[k:string]:${type}`]),
+    };
+};
 export const primitive = (c) => {
     if (c === null) {
         return 'null';