functionalscript 0.17.0 → 0.18.0

package/fs/types/function/operator/test.f.js

@@ -0,0 +1,81 @@
+import { join, concat, logicalNot, strictEqual, addition, min, max, increment, foldToScan, reduceToScan, } from "./module.f.js";
+export const joinTest = () => {
+    const result = join(', ')('world')('hello');
+    if (result !== 'hello, world') {
+        throw result;
+    }
+};
+export const concatTest = () => {
+    const result = concat('world')('hello');
+    if (result !== 'helloworld') {
+        throw result;
+    }
+};
+export const logicalNotTest = () => {
+    if (logicalNot(true) !== false) {
+        throw 'expected false';
+    }
+    if (logicalNot(false) !== true) {
+        throw 'expected true';
+    }
+};
+export const strictEqualTest = () => {
+    if (!strictEqual(1)(1)) {
+        throw 'expected true';
+    }
+    if (strictEqual(1)(2)) {
+        throw 'expected false';
+    }
+};
+export const additionTest = () => {
+    const result = addition(3)(4);
+    if (result !== 7) {
+        throw result;
+    }
+};
+export const minTest = () => {
+    if (min(3)(5) !== 3) {
+        throw 'min(3)(5)';
+    }
+    if (min(7)(2) !== 2) {
+        throw 'min(7)(2)';
+    }
+};
+export const maxTest = () => {
+    if (max(3)(5) !== 5) {
+        throw 'max(3)(5)';
+    }
+    if (max(7)(2) !== 7) {
+        throw 'max(7)(2)';
+    }
+};
+export const incrementTest = () => {
+    if (increment(4) !== 5) {
+        throw 'increment(4)';
+    }
+    if (increment(0) !== 1) {
+        throw 'increment(0)';
+    }
+};
+export const foldToScanTest = () => {
+    const scan = foldToScan(addition)(0);
+    const [v1, scan2] = scan(3);
+    if (v1 !== 3) {
+        throw v1;
+    }
+    const [v2] = scan2(4);
+    if (v2 !== 7) {
+        throw v2;
+    }
+};
+export const reduceToScanTest = () => {
+    const scan = reduceToScan(addition);
+    const [v0, scan2] = scan(10);
+    if (v0 !== 10) {
+        throw v0;
+    }
+    const [v1] = scan2(5);
+    if (v1 !== 15) {
+        throw v1;
+    }
+};

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

@@ -37,6 +37,7 @@
 import { genericMerge } from "../sorted_list/module.f.js";
 import { next } from "../list/module.f.js";
 import { cmp } from "../number/module.f.js";
+import { bsearch } from "../function/compare/module.f.js";
 const reduceOp = ({ union, equal }) => state => ([aItem, aMax]) => ([bItem, bMax]) => {
     const sign = cmp(aMax)(bMax);
     const min = sign === 1 ? bMax : aMax;
@@ -59,24 +60,8 @@ const tailReduce = equal => state => tail => {
 };
 export const merge = op => genericMerge({ reduceOp: reduceOp(op), tailReduce: tailReduce(op.equal) })(null);
 export const get = def => value => rm => {
-    const len = rm.length;
-    let b = 0;
-    let e = len - 1;
-    while (true) {
-        if (b >= len) {
-            return def;
-        }
-        if (e - b < 0) {
-            return rm[b][0];
-        }
-        const mid = b + (e - b >> 1);
-        if (value <= rm[mid][1]) {
-            e = mid - 1;
-        }
-        else {
-            b = mid + 1;
-        }
-    }
+    const pos = bsearch(rm.length)(mid => value <= rm[mid][1] ? -1 : 1);
+    return pos < rm.length ? rm[pos][0] : def;
 };
 export const fromRange = def => ([a, b]) => v => [[def, a - 1], [v, b]];
 /**

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

@@ -51,3 +51,7 @@ export declare const error: <E>(e: E) => Error<E>;
  * @returns The value if the result is successful. Otherwise, throws the error.
  */
 export declare const unwrap: <T, E>([kind, v]: Result<T, E>) => T;
+/**
+ * Swaps the `ok` and `error` cases of a result.
+ */
+export declare const invert: <T, E>([k, v]: Result<T, E>) => Result<E, T>;

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

@@ -44,3 +44,7 @@ export const unwrap = ([kind, v]) => {
     }
     return v;
 };
+/**
+ * Swaps the `ok` and `error` cases of a result.
+ */
+export const invert = ([k, v]) => k === 'ok' ? error(v) : ok(v);

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

@@ -1,4 +1,2 @@
-declare const _default: {
-    example: () => void;
-};
-export default _default;
+export declare const example: () => void;
+export declare const invertTest: () => void;

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

@@ -1,18 +1,26 @@
-import { error, ok, unwrap } from "./module.f.js";
-export default {
-    example: () => {
-        const success = ok(42);
-        const failure = error('Something went wrong');
-        if (unwrap(success) !== 42) {
-            throw 'error';
-        }
-        const [kind, v] = failure;
-        if (kind !== 'error') {
-            throw 'error';
-        }
-        // `v` is inferred as `string` here
-        if (v !== 'Something went wrong') {
-            throw 'error';
-        }
+import { error, ok, unwrap, invert } from "./module.f.js";
+export const example = () => {
+    const success = ok(42);
+    const failure = error('Something went wrong');
+    if (unwrap(success) !== 42) {
+        throw 'error';
+    }
+    const [kind, v] = failure;
+    if (kind !== 'error') {
+        throw 'error';
+    }
+    // `v` is inferred as `string` here
+    if (v !== 'Something went wrong') {
+        throw 'error';
+    }
+};
+export const invertTest = () => {
+    const [k0, v0] = invert(ok(42));
+    if (k0 !== 'error' || v0 !== 42) {
+        throw [k0, v0];
+    }
+    const [k1, v1] = invert(error('oops'));
+    if (k1 !== 'ok' || v1 !== 'oops') {
+        throw [k1, v1];
     }
 };

package/fs/types/rtti/common/module.f.d.ts

@@ -23,9 +23,10 @@
  * @module
  */
 import type { Primitive, Unknown } from '../../../djs/module.f.ts';
-import { type Info0, type Primitive0, type Struct, type Tuple, type Type } from '../module.f.ts';
+import { type Info0, type Primitive0, type Struct, type Tag1, type Tuple, type Type } from '../module.f.ts';
 import { type Error, type Result as CommonResult } from '../../result/module.f.ts';
 import type { Ts } from '../ts/module.f.ts';
+import { type ReadonlyRecord } from '../../object/module.f.ts';
 /** A path to a sub-value within the validated structure. Each step is an object key or stringified array index. */
 export type Path = readonly string[];
 /** Detailed validation failure: the offending `path` plus a short `message`. */
@@ -65,6 +66,14 @@ export type Visitor<R> = {
     readonly primitive0: (tag: Primitive0) => R;
     readonly unknown: () => R;
 };
+/** Type guard narrowing `Unknown` to a specific container type `C`. */
+export type IsContainer<C extends Unknown> = (value: Unknown) => value is C;
+/** Maps a `Tag1` to its runtime container type. */
+export type Container<K extends Tag1> = K extends 'array' ? ReadonlyArray<Unknown> : ReadonlyRecord<string, Unknown>;
+/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
+export declare const isArray: IsContainer<ReadonlyArray<Unknown>>;
+/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
+export declare const isObject: IsContainer<ReadonlyRecord<string, Unknown>>;
 /**
  * Visits a schema `Type` by dispatching to the matching handler in `v`.
  *

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

@@ -1,6 +1,7 @@
 import {} from "../module.f.js";
 import { error, ok } from "../../result/module.f.js";
-import { isArray } from "../../array/module.f.js";
+import { isArray as commonIsArray } from "../../array/module.f.js";
+import { isObject as commonIsObject } from "../../object/module.f.js";
 /** Builds an error result with empty path and the given message. */
 export const verror = (message) => error({ path: [], message });
 /** Prepends `key` to the error's path, used to build the path bottom-up. */
@@ -18,8 +19,12 @@ export const constPrimitiveValidate = (rtti) => value => Object.is(rtti, value)
     ? ok(value)
     : verror('unexpected value');
 const visitConst = (v) => (c) => typeof c === 'object' && c !== null
-    ? (isArray(c) ? v.tuple(c) : v.struct(c))
+    ? (commonIsArray(c) ? v.tuple(c) : v.struct(c))
     : v.constPrimitive(c);
+/** `IsContainer` guard for arrays, shared by `validate` and `parse`. */
+export const isArray = value => commonIsArray(value);
+/** `IsContainer` guard for records/structs, shared by `validate` and `parse`. */
+export const isObject = value => commonIsObject(value);
 /**
  * Visits a schema `Type` by dispatching to the matching handler in `v`.
  *

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

@@ -1,71 +1,60 @@
 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 {} from "../../object/module.f.js";
 import { find, map as listMap } from "../../list/module.f.js";
-import { constPrimitiveValidate, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
+import { constPrimitiveValidate, isArray, isObject, prependPath, primitive0Validate, verror, visit, } from "../common/module.f.js";
 export {} from "../common/module.f.js";
-const indexedFirstError = (results) => {
-    // TODO: findIndex breaks type inference,
-    //       we should replace it with something else.
-    const i = results.findIndex(r => r[0] === 'error');
-    return i < 0 ? null : [i, results[i]];
-};
+const { entries } = Object;
 const keyedFirstError = (results) => {
     const e = results.find(([, r]) => r[0] === 'error');
     return e === undefined ? null : [e[0], e[1]];
 };
-const arrayParse = (item) => value => {
-    if (!commonIsArray(value)) {
-        return verror('unexpected value');
-    }
-    if (value.length === 0) {
-        return ok([]);
-    }
-    // Note: we shouldn't instantiate `itemParse` until we know the array is non-empty.
-    //       Otherwise, we can get infinite recursion on empty arrays for recursive schemas.
-    const itemParse = parse(item);
-    const results = value.map(itemParse);
-    const err = indexedFirstError(results);
-    return (err === null
-        ? ok(results.map(r => r[1]))
-        : prependPath(String(err[0]), err[1]));
-};
-const recordParse = (item) => value => {
-    if (!commonIsObject(value)) {
+const arrayRebuild = entries => entries.map(([, v]) => v);
+const recordRebuild = entries => Object.fromEntries(entries);
+/** Drops the `'ok'` tag from each result, yielding the rebuild's `[key, value]` entries. */
+const okEntries = (results) => results.map(([k, r]) => [k, r[1]]);
+/**
+ * Builds a parser for `array` or `record` schemas. Mirrors `validate`'s
+ * `containerValidate`, but rebuilds a fresh container from each item's parsed
+ * result instead of returning the value unchanged. The inner item parser is
+ * instantiated lazily (only when the container is non-empty) so recursive
+ * schemas don't recurse forever on empty containers.
+ */
+const containerParse = (isContainer, rebuild) => (item) => value => {
+    if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const entries = Object.entries(value);
-    if (entries.length === 0) {
-        return ok({});
+    const e = entries(value);
+    if (e.length === 0) {
+        return ok(rebuild([]));
     }
     const itemParse = parse(item);
-    const results = entries.map(([k, v]) => [k, itemParse(v)]);
+    const results = e.map(([k, v]) => [k, itemParse(v)]);
     const err = keyedFirstError(results);
     return (err === null
-        ? ok(Object.fromEntries(results.map(([k, r]) => [k, r[1]])))
+        ? ok(rebuild(okEntries(results)))
         : prependPath(err[0], err[1]));
 };
-const tupleParse = (rtti) => value => {
-    if (!commonIsArray(value)) {
-        return verror('unexpected value');
-    }
-    const results = rtti.map((t, i) => parse(t)(value[i]));
-    const err = indexedFirstError(results);
-    return (err === null
-        ? ok(results.map(r => r[1]))
-        : prependPath(String(err[0]), err[1]));
-};
-const structParse = (rtti) => value => {
-    if (!commonIsObject(value)) {
+const arrayParse = containerParse(isArray, arrayRebuild);
+const recordParse = containerParse(isObject, recordRebuild);
+/**
+ * Builds a parser for `Tuple` or `Struct` const schemas. Mirrors `validate`'s
+ * `constContainerValidate`: it iterates the schema's entries (so extra tuple
+ * elements and undeclared struct keys are dropped) and rebuilds the result
+ * from each parsed item.
+ */
+const constContainerParse = (isContainer, getItem, rebuild) => (rtti) => value => {
+    if (!isContainer(value)) {
         return verror('unexpected value');
     }
-    const results = Object.entries(rtti).map(([k, t]) => [k, parse(t)(value[k])]);
+    const results = entries(rtti).map(([k, t]) => [k, parse(t)(getItem(value, k))]);
     const err = keyedFirstError(results);
     return (err === null
-        ? ok(Object.fromEntries(results.map(([k, r]) => [k, r[1]])))
+        ? ok(rebuild(okEntries(results)))
         : prependPath(err[0], err[1]));
 };
+const tupleParse = constContainerParse(isArray, (value, k) => value[Number(k)], arrayRebuild);
+const structParse = constContainerParse(isObject, (value, k) => value[k], recordRebuild);
 const findFirst = find(verror('no match'))((k) => k[0] === 'ok');
 const orParse = (rtti) => value => findFirst(listMap(t => parse(t)(value))(rtti));
 /**

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.18.0",
   "type": "module",
   "files": [
     "**/*.js",