functionalscript 0.17.0 → 0.19.0

package/fs/types/rtti/validate/module.f.js

@@ -1,26 +1,26 @@
 import {} from "../module.f.js";
 import { ok } from "../../result/module.f.js";
-import { isArray as commonIsArray } from "../../array/module.f.js";
-import { isObject as commonIsObject } from "../../object/module.f.js";
-import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+import {} from "../../object/module.f.js";
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
 export { constPrimitiveValidate, prependPath, primitive0Validate, verror, } from "../common/module.f.js";
+const { entries } = Object;
 /**
  * Builds a validator for `array` or `record` schemas.
  * The inner item validator is instantiated lazily (only when the container is
  * non-empty) to avoid infinite recursion with recursive schemas.
  */
-const containerValidate = (isContainer, getEntries) => (item) => value => {
+const containerValidate = (isContainer) => (item) => value => {
     if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const entries = getEntries(value);
-    if (entries.length === 0) {
+    const e = entries(value);
+    if (e.length === 0) {
         return ok(value);
     }
     // Note: we shouldn't instantiate `itemValidate` until we make sure `entries` is not empty.
     //       Otherwise, we can get infinite recursion on empty arrays and objects
     const itemValidate = validate(item);
-    for (const [k, v] of entries) {
+    for (const [k, v] of e) {
         const r = itemValidate(v);
         if (r[0] === 'error') {
             return prependPath(k, r);
@@ -28,11 +28,8 @@ const containerValidate = (isContainer, getEntries) => (item) => value => {
     }
     return ok(value);
 };
-const isArray = value => commonIsArray(value);
-const arrayEntries = (value) => value.map((v, i) => [String(i), v]);
-const arrayValidate = containerValidate(isArray, arrayEntries);
-const isObject = value => commonIsObject(value);
-const recordValidate = containerValidate(isObject, Object.entries);
+const arrayValidate = containerValidate(isArray);
+const recordValidate = containerValidate(isObject);
 /**
  * Builds a validator for `Tuple` or `Struct` const schemas.
  * Iterates over the schema's entries and validates each corresponding

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

@@ -3,12 +3,11 @@
  *
  * @module
  */
-import type { Sign } from '../function/compare/module.f.ts';
+import { type Sign, type Cmp } from '../function/compare/module.f.ts';
 import { type List } from '../list/module.f.ts';
 import type { Nullable } from '../nullable/module.f.ts';
 export type SortedList<T> = List<T>;
 type SortedArray<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Sign;
 export type ReduceOp<T, S> = (state: S) => (a: T) => (b: T) => readonly [Nullable<T>, Sign, S];
 export type TailReduce<T, S> = (state: S) => (tail: List<T>) => List<T>;
 type MergeReduce<T, S> = {

package/fs/types/sorted_list/module.f.js

@@ -1,3 +1,9 @@
+/**
+ * Sorted immutable list helpers and merge operations.
+ *
+ * @module
+ */
+import { bsearch } from "../function/compare/module.f.js";
 import { next } from "../list/module.f.js";
 import { identity } from "../function/module.f.js";
 export const genericMerge = ({ reduceOp, tailReduce }) => {
@@ -29,25 +35,6 @@ const cmpReduce = (cmp) => () => a => b => {
 const mergeTail = () => identity;
 export const find = (cmp) => (value) => (array) => {
     const cmpValue = cmp(value);
-    let b = 0;
-    let e = array.length - 1;
-    while (true) {
-        const d = e - b;
-        if (d < 0)
-            return null;
-        const mid = b + (d >> 1);
-        switch (cmpValue(array[mid])) {
-            case -1: {
-                e = mid - 1;
-                break;
-            }
-            case 0: {
-                return value;
-            }
-            case 1: {
-                b = mid + 1;
-                break;
-            }
-        }
-    }
+    const pos = bsearch(array.length)(mid => cmpValue(array[mid]));
+    return pos < array.length && cmpValue(array[pos]) === 0 ? value : null;
 };

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

@@ -26,10 +26,8 @@
  * has(cmp)(2)(setA) // false
  * ```
  */
-import type { Sign } from '../function/compare/module.f.ts';
+import type { Cmp } from '../function/compare/module.f.ts';
 export type SortedSet<T> = readonly T[];
-type Cmp<T> = (a: T) => (b: T) => Sign;
 export declare const union: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const intersect: <T>(cmp: Cmp<T>) => (a: SortedSet<T>) => (b: SortedSet<T>) => SortedSet<T>;
 export declare const has: <T>(cmp: Cmp<T>) => (value: T) => (set: SortedSet<T>) => boolean;
-export {};

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

@@ -0,0 +1,18 @@
+export declare const primitiveNull: () => void;
+export declare const primitiveBigint: () => void;
+export declare const primitiveString: () => void;
+export declare const primitiveNumberFinite: () => void;
+export declare const primitiveNumberInfinite: () => void;
+export declare const primitiveUndefined: () => void;
+export declare const primitiveBoolean: () => void;
+export declare const unionEmpty: () => void;
+export declare const unionSingle: () => void;
+export declare const unionMulti: () => void;
+export declare const printerReadonlyTuple: () => void;
+export declare const printerReadonlyStruct: () => void;
+export declare const printerReadonlyArray: () => void;
+export declare const printerReadonlyRecord: () => void;
+export declare const printerMutableTuple: () => void;
+export declare const printerMutableStruct: () => void;
+export declare const printerMutableArray: () => void;
+export declare const printerMutableRecord: () => void;

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

@@ -0,0 +1,111 @@
+import { printer, primitive, union } from "./module.f.js";
+const ro = printer();
+const mut = printer(true);
+export const primitiveNull = () => {
+    const r = primitive(null);
+    if (r !== 'null') {
+        throw r;
+    }
+};
+export const primitiveBigint = () => {
+    const r = primitive(42n);
+    if (r !== '42n') {
+        throw r;
+    }
+};
+export const primitiveString = () => {
+    const r = primitive('hello');
+    if (r !== '"hello"') {
+        throw r;
+    }
+};
+export const primitiveNumberFinite = () => {
+    const r = primitive(3.14);
+    if (r !== '3.14') {
+        throw r;
+    }
+};
+export const primitiveNumberInfinite = () => {
+    const r = primitive(Infinity);
+    if (r !== 'number') {
+        throw r;
+    }
+};
+export const primitiveUndefined = () => {
+    const r = primitive(undefined);
+    if (r !== 'undefined') {
+        throw r;
+    }
+};
+export const primitiveBoolean = () => {
+    const r = primitive(true);
+    if (r !== 'true') {
+        throw r;
+    }
+};
+export const unionEmpty = () => {
+    const r = union([]);
+    if (r !== 'never') {
+        throw r;
+    }
+};
+export const unionSingle = () => {
+    const r = union(['string']);
+    if (r !== 'string') {
+        throw r;
+    }
+};
+export const unionMulti = () => {
+    const r = union(['string', 'number']);
+    if (r !== 'string|number') {
+        throw r;
+    }
+};
+export const printerReadonlyTuple = () => {
+    const r = ro.tuple(['string', 'number']);
+    if (r !== 'readonly[string,number]') {
+        throw r;
+    }
+};
+export const printerReadonlyStruct = () => {
+    const r = ro.struct([['x', 'number'], ['y', 'string']]);
+    if (r !== '{readonly"x":number,readonly"y":string}') {
+        throw r;
+    }
+};
+export const printerReadonlyArray = () => {
+    const r = ro.array('string');
+    if (r !== 'readonly(string)[]') {
+        throw r;
+    }
+};
+export const printerReadonlyRecord = () => {
+    const r = ro.record('number');
+    if (r !== '{readonly[k:string]:number}') {
+        throw r;
+    }
+};
+export const printerMutableTuple = () => {
+    const r = mut.tuple(['string', 'number']);
+    if (r !== '[string,number]') {
+        throw r;
+    }
+};
+export const printerMutableStruct = () => {
+    const r = mut.struct([['x', 'number']]);
+    if (r !== '{"x":number}') {
+        throw r;
+    }
+};
+export const printerMutableArray = () => {
+    const r = mut.array('string');
+    if (r !== '(string)[]') {
+        throw r;
+    }
+};
+export const printerMutableRecord = () => {
+    const r = mut.record('number');
+    if (r !== '{[k:string]:number}') {
+        throw r;
+    }
+};

package/fs/types/uint8array/module.f.js

@@ -1,5 +1,11 @@
 /**
- * Conversions between Uint8Array values and bit vectors.
+ * Conversions between `Uint8Array` values and bit vectors.
+ *
+ * @deprecated FunctionalScript represents byte data as `bigint`-based bit
+ * vectors (`Vec` from `fs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fs/text` for string encoding, and the `bit_vec` module directly for raw
+ * byte manipulation. `Uint8Array` interop belongs at Node.js boundaries only
+ * (e.g. `fromVec`/`toVec` when reading or writing files).
  *
  * @module
  */

package/fs/types/uint8array/test.f.d.ts

@@ -8,5 +8,6 @@ declare const _default: {
     decodeUtf8Ascii: () => void;
     decodeUtf8Multibyte: () => void;
     utf8RoundTrip: () => void;
+    listToVec: () => void;
 };
 export default _default;

package/fs/types/uint8array/test.f.js

@@ -1,5 +1,5 @@
 import { vec } from "../bit_vec/module.f.js";
-import { toVec, fromVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
+import { toVec, fromVec, listToVec, decodeUtf8, encodeUtf8 } from "./module.f.js";
 import { strictEqual } from "../function/operator/module.f.js";
 import { equal, fromArrayLike } from "../list/module.f.js";
 const assertEq = (a, b) => {
@@ -54,5 +54,9 @@ export default {
         const input = 'FunctionalScript 🐝';
         const output = decodeUtf8(encodeUtf8(input));
         assertEq(output, input);
+    },
+    listToVec: () => {
+        const result = listToVec([Uint8Array.from([1, 2]), Uint8Array.from([3])]);
+        assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
     }
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,17 +9,17 @@
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
     "prepack": "tsc --NoEmit false",
-    "test": "tsc && node --test --experimental-strip-types --experimental-test-coverage --test-coverage-include=**/module.f.ts",
+    "test": "tsc && node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
     "index": "node ./fs/fjs/module.ts r ./fs/dev/index/module.f.ts",
     "fst": "node ./fs/fjs/module.ts t",
     "start": "node ./fs/fjs/module.ts",
     "ci-update": "node ./fs/fjs/module.ts r ./fs/ci/module.f.ts",
     "update": "npm install && npm run index && npm run ci-update",
-    "index-html": "node --experimental-strip-types ./fs/fjs/module.ts r ./fs/website/module.f.ts",
+    "index-html": "node ./fs/fjs/module.ts r ./fs/website/module.f.ts",
     "website": "npm run prepack &&npm run index-html"
   },
   "engines": {
-    "node": ">=22"
+    "node": ">=24"
   },
   "bin": {
     "fjs": "fs/fjs/module.js"