functionalscript 0.36.0 → 0.38.0

package/{fs → fjs}/types/string_set/module.f.js

@@ -19,13 +19,13 @@
  * if (contains('banana')(mySet)) { throw '4' }
  * ```
  */
-import { empty as btEmpty, values as btValues } from "../btree/module.f.js";
-import { find, isFound } from "../btree/find/module.f.js";
-import { remove as btreeRemove } from "../btree/remove/module.f.js";
-import { set as btreeSet } from "../btree/set/module.f.js";
+import { empty as btEmpty, values as btValues } from '../btree/module.f.js';
+import { find, isFound } from '../btree/find/module.f.js';
+import { remove as btreeRemove } from '../btree/remove/module.f.js';
+import { set as btreeSet } from '../btree/set/module.f.js';
 import { cmp } from "../string/module.f.js";
-import { fold } from "../list/module.f.js";
-import { compose } from "../function/module.f.js";
+import { fold } from '../list/module.f.js';
+import { compose } from '../function/module.f.js';
 export const values = btValues;
 export const empty = btEmpty;
 export const contains = value => {

package/fjs/types/string_set/proof.f.js

@@ -0,0 +1,43 @@
+import { contains, fromValues, remove, set } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    example: () => {
+        let mySet = fromValues(['apple', 'banana', 'cherry']);
+        assert(contains('banana')(mySet), '1');
+        assert(!(contains('date')(mySet)), '2');
+        mySet = set('date')(mySet);
+        assert(contains('date')(mySet), '3');
+        mySet = remove('banana')(mySet);
+        assert(!(contains('banana')(mySet)), '4');
+    },
+    contains: () => {
+        const r = set('hello')(null);
+        assert(contains('hello')(r), r);
+        assert(!(contains('hello1')(r)), r);
+    },
+    remove: () => {
+        let r = set('hello')(null);
+        r = set('world')(r);
+        r = set('HELLO')(r);
+        r = set('WORLD!')(r);
+        assert(contains('hello')(r), r);
+        assert(!(contains('hello1')(r)), r);
+        assert(contains('HELLO')(r), r);
+        assert(!(contains('WORLD')(r)), r);
+        assert(contains('world')(r), r);
+        assert(!(contains('world!')(r)), r);
+        assert(contains('WORLD!')(r), r);
+        //
+        r = remove('hello')(r);
+        assert(!(contains('hello')(r)), r);
+        assert(contains('world')(r), r);
+        r = remove('world')(r);
+        assert(!(contains('world')(r)), r);
+        assert(contains('HELLO')(r), r);
+        r = remove('HELLO')(r);
+        assert(!(contains('HELLO')(r)), r);
+        assert(contains('WORLD!')(r), r);
+        r = remove('WORLD!')(r);
+        assertEq(r, null);
+    }
+};

package/{fs → fjs}/types/ts/proof.f.d.ts

@@ -17,22 +17,22 @@ export declare const printerMutableStruct: () => void;
 export declare const printerMutableArray: () => void;
 export declare const printerMutableRecord: () => void;
 export declare const proof: {
-    primitiveNull: () => void;
-    primitiveBigint: () => void;
-    primitiveString: () => void;
-    primitiveNumberFinite: () => void;
-    primitiveNumberInfinite: () => void;
-    primitiveUndefined: () => void;
-    primitiveBoolean: () => void;
-    unionEmpty: () => void;
-    unionSingle: () => void;
-    unionMulti: () => void;
-    printerReadonlyTuple: () => void;
-    printerReadonlyStruct: () => void;
-    printerReadonlyArray: () => void;
-    printerReadonlyRecord: () => void;
-    printerMutableTuple: () => void;
-    printerMutableStruct: () => void;
-    printerMutableArray: () => void;
-    printerMutableRecord: () => void;
+    primitiveNull: typeof primitiveNull;
+    primitiveBigint: typeof primitiveBigint;
+    primitiveString: typeof primitiveString;
+    primitiveNumberFinite: typeof primitiveNumberFinite;
+    primitiveNumberInfinite: typeof primitiveNumberInfinite;
+    primitiveUndefined: typeof primitiveUndefined;
+    primitiveBoolean: typeof primitiveBoolean;
+    unionEmpty: typeof unionEmpty;
+    unionSingle: typeof unionSingle;
+    unionMulti: typeof unionMulti;
+    printerReadonlyTuple: typeof printerReadonlyTuple;
+    printerReadonlyStruct: typeof printerReadonlyStruct;
+    printerReadonlyArray: typeof printerReadonlyArray;
+    printerReadonlyRecord: typeof printerReadonlyRecord;
+    printerMutableTuple: typeof printerMutableTuple;
+    printerMutableStruct: typeof printerMutableStruct;
+    printerMutableArray: typeof printerMutableArray;
+    printerMutableRecord: typeof printerMutableRecord;
 };

package/{fs → fjs}/types/ts/proof.f.js

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

package/{fs → fjs}/types/uint8array/module.f.js

@@ -2,30 +2,30 @@
  * 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
+ * vectors (`Vec` from `fjs/types/bit_vec`). Use `utf8`/`utf8ToString` from
+ * `fjs/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
  */
-import { utf8, utf8ToString } from "../../text/module.f.js";
-import { maxLengthBytes, msb, u8List, u8ListToVec } from "../bit_vec/module.f.js";
-import { compose } from "../function/module.f.js";
-import { flat, fromArrayLike, iterable, map } from "../list/module.f.js";
+import { assert, assertNotNullish } from '../../asserts/module.f.js';
+import { utf8, utf8ToString } from '../../text/module.f.js';
+import { maxLengthBytes, msb, tryU8ListToVec, u8List, u8ListToVec } from '../bit_vec/module.f.js';
+import { compose } from '../function/module.f.js';
+import { flat, fromArrayLike, iterable, map } from '../list/module.f.js';
 const u8ListToVecMsb = u8ListToVec(msb);
+const tryU8ListToVecMsb = tryU8ListToVec(msb);
 const u8ListMsb = u8List(msb);
 /**
  * Converts a Uint8Array into an MSB-first bit vector.
  */
 export const toVec = (input) => {
-    if (input.length > maxLengthBytes) {
-        throw "the array is too big";
-    }
+    assert(input.length <= maxLengthBytes, "the array is too big");
     return u8ListToVecMsb(fromArrayLike(input));
 };
 const m = map(fromArrayLike);
-export const listToVec = (input) => u8ListToVecMsb(flat(m(input)));
+export const listToVec = (input) => assertNotNullish(tryU8ListToVecMsb(flat(m(input))), "the array is too big");
 /**
  * Converts an MSB-first bit vector into a Uint8Array.
  */

package/{fs → fjs}/types/uint8array/proof.f.d.ts

@@ -10,5 +10,8 @@ export declare const proof: {
     utf8RoundTrip: () => void;
     listToVec: () => void;
     maxLength: () => import("../bit_vec/module.f.ts").Vec;
-    throw: () => import("../bit_vec/module.f.ts").Vec;
+    throw: {
+        toVec: () => import("../bit_vec/module.f.ts").Vec;
+        listToVec: () => import("../bit_vec/module.f.ts").Vec;
+    };
 };

package/{fs → fjs}/types/uint8array/proof.f.js

@@ -1,16 +1,13 @@
-import { maxLength, maxLengthBytes, vec } from "../bit_vec/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";
+import { maxLength, maxLengthBytes, vec } from '../bit_vec/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';
+import { assert } from '../../asserts/module.f.js';
 const assertEq = (a, b) => {
-    if (a !== b) {
-        throw [a, b];
-    }
+    assert(a === b, [a, b]);
 };
 const assertArrayEq = (a, b) => {
-    if (!equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b))) {
-        throw [a, b];
-    }
+    assert(equal(strictEqual)(fromArrayLike(a))(fromArrayLike(b)), [a, b]);
 };
 export const proof = {
     empty: () => {
@@ -60,5 +57,8 @@ export const proof = {
         assertArrayEq(fromVec(result), Uint8Array.from([1, 2, 3]));
     },
     maxLength: () => toVec(new Uint8Array(Number(maxLengthBytes))),
-    throw: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+    throw: {
+        toVec: () => toVec(new Uint8Array(Number(maxLengthBytes) + 1)),
+        listToVec: () => listToVec([new Uint8Array(Number(maxLengthBytes)), Uint8Array.from([0])]),
+    },
 };

package/{fs → fjs}/website/module.f.js

@@ -3,9 +3,9 @@
  *
  * @module
  */
-import { htmlUtf8 } from "../html/module.f.js";
-import { writeFile } from "../effects/node/module.f.js";
-import { pure } from "../effects/module.f.js";
+import { htmlUtf8 } from '../media/html/module.f.js';
+import { writeFile } from '../effects/node/module.f.js';
+import { pure } from '../effects/module.f.js';
 const html = htmlUtf8()(['a',
     { href: 'https://github.com/functionalscript/functionalscript' },
     'GitHub Repository'

package/fjs/website/proof.f.js

@@ -0,0 +1,13 @@
+import { main } from './module.f.js';
+import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
+import { assertEq, assertNotNullish } from '../asserts/module.f.js';
+export const proof = {
+    main: () => {
+        assertNotNullish(main(), 'expected a program effect');
+    },
+    run: () => {
+        const state = { ...emptyState, root: { '.github': { workflows: {} } } };
+        const [_, result] = virtual(state)(main());
+        assertEq(result, 0);
+    },
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.36.0",
+  "version": "0.38.0",
   "type": "module",
   "files": [
     "**/*.js",
@@ -9,19 +9,19 @@
   "description": "FunctionalScript is a purely functional subset of JavaScript",
   "scripts": {
     "prepack": "tsc --NoEmit false",
-    "test": "tsc && node ./fs/fjs/module.ts t",
+    "test": "tsc && node ./fjs/module.ts t",
     "cov": "node --test --experimental-test-coverage --test-coverage-include=**/module.f.ts",
-    "start": "node ./fs/fjs/module.ts",
-    "ci-update": "node ./fs/fjs/module.ts ci",
+    "start": "node ./fjs/module.ts",
+    "ci-update": "node ./fjs/module.ts ci",
     "update": "npx npm-check-updates -u && npm install && deno install && bun install && npm run ci-update",
-    "index-html": "node ./fs/fjs/module.ts r ./fs/website/module.f.ts",
+    "index-html": "node ./fjs/module.ts r ./fjs/website/module.f.ts",
     "website": "npm run prepack && npm run index-html"
   },
   "engines": {
     "node": ">=22"
   },
   "bin": {
-    "fjs": "fs/fjs/module.js"
+    "fjs": "fjs/module.js"
   },
   "repository": {
     "type": "git",
@@ -44,7 +44,7 @@
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
     "@playwright/test": "1.61.1",
-    "@types/node": "26.1.0",
-    "typescript": "6.0.3"
+    "@types/node": "26.1.1",
+    "typescript": "7.0.2"
   }
 }

package/fs/asserts/module.f.d.ts

@@ -1,4 +0,0 @@
-export declare const todo: () => never;
-export declare const assert: (v: boolean, msg?: unknown) => asserts v;
-export declare const assertEq: <T>(...x: readonly [T, T, unknown?]) => void;
-export type Assert<T extends true> = T;

package/fs/asserts/module.f.js

@@ -1,9 +0,0 @@
-export const todo = () => { throw 'not implemented'; };
-export const assert = (v, msg = 'assertion failed') => {
-    if (!v)
-        throw msg;
-};
-export const assertEq = (...x) => {
-    const [a, b] = x;
-    assert(a === b, x);
-};

package/fs/asserts/proof.f.d.ts

@@ -1,8 +0,0 @@
-export declare const proof: {
-    assertPassesOnTrue: () => void;
-    assertThrowsDefaultMsg: () => void;
-    assertThrowsCustomMsg: () => void;
-    assertEqPassesOnEqual: () => void;
-    assertEqThrowsOnUnequal: () => void;
-    todoThrows: () => void;
-};

package/fs/asserts/proof.f.js

@@ -1,51 +0,0 @@
-import { assert, assertEq, todo } from "./module.f.js";
-const throws = (f, expected) => {
-    let caught = false;
-    try {
-        f();
-    }
-    catch (e) {
-        caught = true;
-        if (e !== expected) {
-            throw ['unexpected throw value', e];
-        }
-    }
-    if (!caught) {
-        throw 'expected function to throw but it did not';
-    }
-};
-export const proof = {
-    assertPassesOnTrue: () => {
-        assert(true);
-        assert(true, 'with message');
-    },
-    assertThrowsDefaultMsg: () => {
-        throws(() => assert(false), 'assertion failed');
-    },
-    assertThrowsCustomMsg: () => {
-        throws(() => assert(false, 'oops'), 'oops');
-    },
-    assertEqPassesOnEqual: () => {
-        assertEq(1, 1);
-        assertEq('x', 'x');
-    },
-    assertEqThrowsOnUnequal: () => {
-        let caught = false;
-        try {
-            assertEq(1, 2);
-        }
-        catch (e) {
-            caught = true;
-            const arr = e;
-            if (arr[0] !== 1 || arr[1] !== 2) {
-                throw ['wrong throw value', e];
-            }
-        }
-        if (!caught) {
-            throw 'expected assertEq to throw';
-        }
-    },
-    todoThrows: () => {
-        throws(() => todo(), 'not implemented');
-    },
-};

package/fs/bnf/data/module.f.d.ts

@@ -1,30 +0,0 @@
-import { type Rule as FRule } from '../module.f.ts';
-import { type StringMap } from '../../types/object/module.f.ts';
-/**
- * Encoded terminal range value used by BNF data rules.
- *
- * The same as the functional TerminalRange.
- */
-export type TerminalRange = number;
-/**
- * Ordered list of grammar rule names.
- */
-export type Sequence = readonly string[];
-/** A variant of rule names. */
-export type Variant = StringMap<string, string>;
-/**
- * Grammar rule definition.
- *
- * It can be one of:
- * - a tagged variant map,
- * - a sequence of referenced rule names,
- * - an encoded terminal range.
- */
-export type Rule = Variant | Sequence | TerminalRange;
-/** The full grammar */
-export type RuleSet = Readonly<Record<string, Rule>>;
-/**
- * Converts a functional grammar rule into serializable BNF data and returns
- * the generated rule set with the entry rule identifier.
- */
-export declare const toData: (fr: FRule) => readonly [RuleSet, string];

package/fs/bnf/descent/module.f.js

@@ -1,119 +0,0 @@
-/**
- * Recursive descent matcher backend over the BNF data {@link RuleSet}.
- *
- * Built from the serializable IR in `fs/bnf/data`, this is a sibling of the
- * LL(1) dispatch builder (`fs/bnf/ll1`). It walks the grammar by recursive
- * descent and preserves per-code-point metadata, producing a metadata-aware
- * AST ({@link AstRuleMeta}). It also exposes {@link createEmptyTagMap}, which
- * records whether each rule can match the empty input.
- *
- * @module
- */
-import {} from "../../text/utf16/module.f.js";
-import { rangeDecode } from "../module.f.js";
-import { contains as rangeContains } from "../../types/range/module.f.js";
-import { definedEntries } from "../../types/object/module.f.js";
-import { toData } from "../data/module.f.js";
-import {} from "../module.f.js";
-const emptyTagMapAdd = (ruleSet) => (map) => (name) => {
-    if (name in map) {
-        return [ruleSet, map, map[name]];
-    }
-    const rule = ruleSet[name];
-    if (typeof rule === 'number') {
-        return [ruleSet, { ...map, [name]: false }, false];
-    }
-    else if (rule instanceof Array) {
-        map = { ...map, [name]: true };
-        let emptyTag = rule.length == 0;
-        for (const item of rule) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (emptyTag === false) {
-                emptyTag = itemEmptyTag !== false;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-    else {
-        map = { ...map, [name]: true };
-        const entries = definedEntries(rule);
-        let emptyTag = false;
-        for (const [tag, item] of entries) {
-            const [, newMap, itemEmptyTag] = emptyTagMapAdd(ruleSet)(map)(item);
-            map = newMap;
-            if (itemEmptyTag !== false) {
-                emptyTag = tag;
-            }
-        }
-        return [ruleSet, { ...map, [name]: emptyTag }, emptyTag];
-    }
-};
-/**
- * Creates a map that describes whether each rule can consume empty input and,
- * for tagged variants, which tag represents the empty match.
- */
-export const createEmptyTagMap = (data) => {
-    return emptyTagMapAdd(data[0])({})(data[1])[1];
-};
-/**
- * Creates a recursive descent parser that preserves metadata for each consumed
- * code point.
- */
-export const descentParser = (fr) => {
-    const data = toData(fr);
-    const emptyTagMap = createEmptyTagMap(data);
-    const getEmptyTag = (name) => {
-        const res = emptyTagMap[name];
-        return res === false ? undefined : res;
-    };
-    const f = (name, tag, cp, idx) => {
-        const mrSuccess = (tag, sequence, idx) => [{ tag, sequence }, true, idx];
-        const mrFail = (tag, sequence, idx) => [{ tag, sequence }, false, idx];
-        const rule = data[0][name];
-        if (typeof rule === 'number') {
-            const emptyTag = getEmptyTag(name);
-            if (idx >= cp.length) {
-                return emptyTag === undefined ? mrFail(emptyTag, [], idx) : mrSuccess(emptyTag, [], idx);
-            }
-            const cpi = cp[idx];
-            const range = rangeDecode(rule);
-            if (rangeContains(range)(cpi[0])) {
-                return mrSuccess(tag, [cpi], idx + 1);
-            }
-            return mrFail(emptyTag, [], idx);
-        }
-        else if (rule instanceof Array) {
-            let seq = [];
-            let tidx = idx;
-            for (const item of rule) {
-                const m = f(item, undefined, cp, tidx);
-                const [astRule, success, nidx] = m;
-                tidx = nidx;
-                if (success === false) {
-                    return mrFail(tag, [], idx);
-                }
-                seq = [...seq, astRule];
-            }
-            return mrSuccess(tag, seq, tidx);
-        }
-        else {
-            const entries = definedEntries(rule);
-            const emptyTag = getEmptyTag(name);
-            let emptyResult = mrFail(emptyTag, [], idx);
-            for (const [tag, item] of entries) {
-                const m = f(item, tag, cp, idx);
-                if (m[1]) {
-                    if (idx !== m[2])
-                        return m;
-                    emptyResult = m;
-                }
-            }
-            return emptyResult;
-        }
-    };
-    const match = (name, cp) => {
-        return f(name, undefined, cp, 0);
-    };
-    return match;
-};