functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/ci/config/module.f.js

@@ -24,13 +24,13 @@ export const images = {
 // published FunctionalScript release; do not tie it to package.json's current
 // in-repo version.
 // https://www.npmjs.com/package/functionalscript
-export const functionalscript = '0.36.0';
+export const functionalscript = '0.38.0';
 // https://bun.sh/
 export const bun = '1.3.14';
 // https://deno.com/
-export const deno = '2.9.2';
+export const deno = '2.9.4';
 // https://www.npmjs.com/package/playwright
-export const playwright = '1.61.1';
+export const playwright = '1.62.0';
 // https://nodejs.org/en/download
 export const node = {
     default: '26.5.0',
@@ -38,18 +38,18 @@ export const node = {
     node24: '24.18.0',
 };
 // https://github.com/bytecodealliance/wasmtime/releases
-export const wasmtime = '46.0.1';
+export const wasmtime = '47.0.2';
 // https://github.com/wasmerio/wasmer/releases
-export const wasmer = '7.2.0';
+export const wasmer = '7.2.1';
 // GitHub Action versions used by CI step builders. The key is the action
 // `owner/name`; call sites compose the full ref as
 // `` `${name}@${actions[name]}` ``.
 // Note: dtolnay/rust-toolchain value is a Rust version, not an action version.
 export const actions = {
     // https://github.com/marketplace/actions/checkout
-    'actions/checkout': 'v7',
+    'actions/checkout': 'v7.0.1',
     // https://github.com/marketplace/actions/setup-node-js-environment
-    'actions/setup-node': 'v6.4.0',
+    'actions/setup-node': 'v7.0.0',
     // https://github.com/marketplace/actions/cache
     'actions/cache': 'v6.1.0',
     // https://github.com/marketplace/actions/setup-deno
@@ -61,5 +61,5 @@ export const actions = {
     // https://github.com/wasmerio/setup-wasmer
     'wasmerio/setup-wasmer': 'v3.1',
     // https://rust-lang.org/ - value is Rust version, not action version
-    'dtolnay/rust-toolchain': '1.96.1',
+    'dtolnay/rust-toolchain': '1.97.1',
 };

package/{fs → fjs}/ci/deno/module.f.js

@@ -5,9 +5,9 @@
  * @module
  */
 import { deno } from '../config/module.f.js';
-import { clean, install, test, uses } from '../common/module.f.js';
+import { install, test, uses } from '../common/module.f.js';
 const denoTest = 'deno test --allow-read --allow-env --allow-sys';
-export const denoSteps = (version) => clean([
+export const denoSteps = (version) => [
     install(uses('denoland/setup-deno', { 'deno-version': deno })),
     // We need --minimum-dependency-age=0 for functionalscript because we would like to use
     // the latest version of the package even if it is not yet 24 hours old,
@@ -17,4 +17,4 @@ export const denoSteps = (version) => clean([
     test({ run: `deno run -A --minimum-dependency-age=0 npm:functionalscript@${version} t` }),
     test({ run: 'deno install --frozen' }),
     test({ run: `${denoTest} --coverage && deno coverage --include='.*module\\.f\\.ts'` }),
-]);
+];

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

@@ -3,7 +3,7 @@
  *
  * @module
  */
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 import { access, writeUtf8File } from '../effects/node/module.f.js';
 import { functionalscript, images } from './config/module.f.js';
 import { architecture, os, toSteps, ubuntuArm } from './common/module.f.js';
@@ -29,7 +29,7 @@ const canonicalJobs = (rust) => ({
     ...nodeVersionJobs(functionalscript),
     playwright: playwrightJob,
 });
-export const ci = ({ nodeExtra }) => access('Cargo.toml').step(result => {
+export const ci = ({ nodeExtra }) => step(access('Cargo.toml'), result => {
     const rust = result[0] === 'ok';
     const jobs = {
         ...Object.fromEntries(os.flatMap(o => architecture.map(job(rust, nodeExtra(o))(o)))),
@@ -46,7 +46,6 @@ export const ci = ({ nodeExtra }) => access('Cargo.toml').step(result => {
         },
         jobs,
     };
-    return writeUtf8File('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '))
-        .step(() => pure(0));
+    return step(writeUtf8File('.github/workflows/ci.yml', JSON.stringify(gha, null, '  ')), () => pure(0));
 });
 export const main = () => ci({ nodeExtra: () => [] });

package/{fs → fjs}/ci/node/module.f.js

@@ -5,38 +5,40 @@
  * @module
  */
 import { node } from '../config/module.f.js';
-import { clean, install, test, ubuntuArm, uses } from '../common/module.f.js';
+import { install, test, ubuntuArm, uses } from '../common/module.f.js';
 export const major = (v) => v.split('.')[0];
 const installNode = (version) => uses('actions/setup-node', { 'node-version': version });
 const nodeInstall = (v) => [
     install(installNode(v)),
     test({ run: 'npm ci' }),
 ];
-export const basicNode = (version) => (extra) => clean([
+export const basicNode = (version) => (extra) => [
     ...nodeInstall(version),
     ...extra,
-]);
+];
 const fjsGlobalInstall = (version) => install({ run: `npm install -g functionalscript@${version}` });
 export const platformNodeSteps = (version) => [
     ...nodeInstall(node.default),
     fjsGlobalInstall(version),
     test({ run: 'fjs t' }),
 ];
-const node22Steps = (version) => clean([
+const node22Steps = (version) => [
     ...nodeInstall(node.node22),
     fjsGlobalInstall(version),
     test({ run: 'fjs t' }),
-]);
-const node24Steps = clean([
+];
+const node24Steps = [
     ...nodeInstall(node.node24),
     test({ run: 'node --test' }),
-]);
-const node26Steps = clean([
+];
+const node26Steps = [
     ...nodeInstall(node.default),
+    test({ run: 'npm run ci-update' }),
+    test({ run: 'git add -A && git diff --cached --exit-code' }),
     test({ run: 'npx tsc' }),
     test({ run: 'npm run cov' }),
     test({ run: 'npm pack' }),
-]);
+];
 const nodeJob = (steps) => ubuntuArm(steps);
 export const nodeVersionJobs = (version) => ({
     [`node${major(node.node22)}`]: nodeJob(node22Steps(version)),

package/{fs → fjs}/ci/proof.f.js

@@ -3,13 +3,14 @@ import { functionalscript } from './config/module.f.js';
 import { utf8, utf8ToString } from '../text/module.f.js';
 import { empty as emptyVec, isVec } from '../types/bit_vec/module.f.js';
 import { test, ubuntu, parseGitHubAction } from './common/module.f.js';
-import { assert } from '../asserts/module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
 import { emptyState, virtual } from '../effects/node/virtual/module.f.js';
 import { parse as jsonParse } from '../media/json/module.f.js';
 import { unwrap } from '../types/result/module.f.js';
 import { definedValues } from '../types/object/module.f.js';
 const hasRun = (cmd) => (gha) => definedValues(gha.jobs).some(job => job.steps.some(step => step.run?.includes(cmd)));
 const hasRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run?.includes(cmd)) ?? false;
+const hasExactRunInJob = (jobId, cmd) => (gha) => gha.jobs[jobId]?.steps.some(step => step.run === cmd) ?? false;
 const makeState = (rust, packageJson) => ({
     ...emptyState,
     root: {
@@ -24,27 +25,25 @@ const workflow = (state) => {
     const workflows = dotGithub['workflows'];
     assert(typeof workflows === 'object' && !Array.isArray(workflows), workflows);
     const file = workflows['ci.yml'];
-    if (!Array.isArray(file) || file.length === 0) {
-        throw file;
-    }
+    assert(!(!Array.isArray(file) || file.length === 0), file);
     return unwrap(parseGitHubAction(jsonParse(utf8ToString(file[0]))));
 };
 const run = (rust, nodeExtra = () => []) => {
     const [state, result] = virtual(makeState(rust))(ci({ nodeExtra }));
-    assert(result === 0, result);
+    assertEq(result, 0);
     return workflow(state);
 };
 const runDefault = (packageJson) => {
     const [state, result] = virtual(makeState(false, packageJson))(main());
-    assert(result === 0, result);
+    assertEq(result, 0);
     return workflow(state);
 };
 export const proof = {
     matrixShape: () => {
         const gha = run(true);
-        assert(Object.keys(gha.jobs).length === 13, 'expected 13 CI jobs');
-        assert(gha.permissions.contents === 'read', 'expected read-only contents permission');
-        assert(Object.keys(gha.permissions).length === 1, 'expected least-privilege workflow permissions');
+        assertEq(Object.keys(gha.jobs).length, 13, 'expected 13 CI jobs');
+        assertEq(gha.permissions.contents, 'read', 'expected read-only contents permission');
+        assertEq(Object.keys(gha.permissions).length, 1, 'expected least-privilege workflow permissions');
         assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu')(gha), 'expected Ubuntu Intel i686 check');
         assert(hasRunInJob('ubuntu-intel', 'cargo test --target i686-unknown-linux-gnu --release')(gha), 'expected Ubuntu Intel i686 release check');
         assert(hasRunInJob('ubuntu-intel', 'cargo clippy --target i686-unknown-linux-gnu -- -D warnings')(gha), 'expected Ubuntu Intel i686 lint');
@@ -55,8 +54,16 @@ export const proof = {
         assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1 --release')(gha), 'expected target-specific WASM release check');
         assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 -- -D warnings')(gha), 'expected target-specific WASM Rust lint');
         assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1 --release -- -D warnings')(gha), 'expected target-specific WASM release lint');
+        // Wasmtime 47 removed wasi-threads: the threads target must run under
+        // Wasmer only, while Clippy (no runner) stays.
+        assert(hasRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --config .cargo/config.wasmer.toml')(gha), 'expected Wasmer WASM threads check');
+        assert(hasRunInJob('wasm', 'cargo clippy --target wasm32-wasip1-threads -- -D warnings')(gha), 'expected WASM threads lint');
+        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads')(gha), 'unexpected Wasmtime WASM threads check');
+        assert(!hasExactRunInJob('wasm', 'cargo test --target wasm32-wasip1-threads --release')(gha), 'unexpected Wasmtime WASM threads release check');
         assert(hasRunInJob('node22', 'fjs t')(gha), 'expected Node 22 FunctionalScript smoke test');
         assert(hasRunInJob('node26', 'npm pack')(gha), 'expected Node 26 package check');
+        assert(hasRunInJob('node26', 'npm run ci-update')(gha), 'expected Node 26 workflow regeneration');
+        assert(hasRunInJob('node26', 'git add -A && git diff --cached --exit-code')(gha), 'expected Node 26 generated-file drift check');
         assert(!hasRun('npm publish --dry-run')(gha), 'unexpected npm publish dry-run');
         for (const id of [
             'ubuntu-intel',

package/{fs → fjs}/ci/rust/module.f.js

@@ -39,6 +39,14 @@ const wasmTarget = (target) => [
     ...targetChecks(target),
     ...cargoTestPair(target, '.cargo/config.wasmer.toml')
 ];
+// Wasmtime 47 removed wasi-threads, so the threads target runs under Wasmer
+// only; Clippy needs no runner and stays. See todo/blocked/wasmtime-threads.md.
+const wasmerOnlyTarget = (target) => [
+    { type: 'rust', target },
+    cargoClippy(target),
+    cargoReleaseClippy(target),
+    ...cargoTestPair(target, '.cargo/config.wasmer.toml')
+];
 const i686 = (a, v) => {
     if (a === 'intel') {
         switch (v) {
@@ -63,5 +71,5 @@ export const rustWasmSteps = [
     ...wasmTarget('wasm32-wasip1'),
     ...wasmTarget('wasm32-wasip2'),
     ...wasmTarget('wasm32-unknown-unknown'),
-    ...wasmTarget('wasm32-wasip1-threads'),
+    ...wasmerOnlyTarget('wasm32-wasip1-threads'),
 ];

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

@@ -1,5 +1,5 @@
 import { errorExit, log } from '../effects/node/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 import { at, fromEntries } from '../types/object/module.f.js';
 const helpMeta = { names: ['help', 'h', '?'], description: 'Print this help message' };
 export const dispatch = (commands) => (options) => {
@@ -23,7 +23,7 @@ export const dispatch = (commands) => (options) => {
                 return dispatch(targetCmd.handler)({ ...options, args: ['help'] });
             }
         }
-        return log(helpText).step(() => pure(0));
+        return step(log(helpText), () => pure(0));
     }
     const found = at(cmd)(map);
     if (found === null) {

package/{fs → fjs}/cli/proof.f.js

@@ -1,6 +1,7 @@
 import { pure } from '../effects/module.f.js';
 import { defaultNodeProgramOptions, emptyState, virtual } from '../effects/node/virtual/module.f.js';
 import { dispatch } from './module.f.js';
+import { assert, assertEq } from '../asserts/module.f.js';
 const makeOptions = (args) => ({ ...defaultNodeProgramOptions, args });
 const echoCommands = [
     {
@@ -13,51 +14,31 @@ const run = (commands) => (args) => virtual(emptyState)(dispatch(commands)(makeO
 export const proof = {
     knownCommand: () => {
         const [, code] = run(echoCommands)(['echo', 'hello']);
-        if (code !== 5) {
-            throw ['expected length 5', code];
-        }
+        assertEq(code, 5, ['expected length 5', code]);
     },
     alias: () => {
         const [, code] = run(echoCommands)(['e', 'hi']);
-        if (code !== 2) {
-            throw ['expected length 2', code];
-        }
+        assertEq(code, 2, ['expected length 2', code]);
     },
     noArgs: () => {
         const [state, code] = run(echoCommands)([]);
-        if (code !== 1) {
-            throw ['expected exit 1', code];
-        }
-        if (state.stderr.length === 0) {
-            throw 'expected error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1', code]);
+        assert(state.stderr.length !== 0, 'expected error in stderr');
     },
     unknownCommand: () => {
         const [state, code] = run(echoCommands)(['bogus']);
-        if (code !== 1) {
-            throw ['expected exit 1', code];
-        }
-        if (state.stderr.length === 0) {
-            throw 'expected error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1', code]);
+        assert(state.stderr.length !== 0, 'expected error in stderr');
     },
     help: () => {
         const [state, code] = run(echoCommands)(['help']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('echo')) {
-            throw 'expected command name in stdout';
-        }
-        if (!state.stdout.includes('help')) {
-            throw 'expected help entry in stdout';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('echo'), 'expected command name in stdout');
+        assert(state.stdout.includes('help'), 'expected help entry in stdout');
     },
     errorIncludesAvailable: () => {
         const [state] = run(echoCommands)(['bogus']);
-        if (!state.stderr.includes('echo')) {
-            throw 'expected available commands in error';
-        }
+        assert(state.stderr.includes('echo'), 'expected available commands in error');
     },
     handlerReceivesRemainingArgs: () => {
         const captured = [];
@@ -70,9 +51,7 @@ export const proof = {
                 },
             }];
         run(commands)(['grab', 'a', 'b', 'c']);
-        if (captured.join(',') !== 'a,b,c') {
-            throw ['unexpected args', captured];
-        }
+        assertEq(captured.join(','), 'a,b,c', ['unexpected args', captured]);
     },
     nestedCommands: () => {
         const inner = [{
@@ -86,9 +65,7 @@ export const proof = {
                 handler: inner,
             }];
         const [, code] = run(outer)(['sub', 'ping']);
-        if (code !== 42) {
-            throw ['expected 42', code];
-        }
+        assertEq(code, 42, ['expected 42', code]);
     },
     nestedHelp: () => {
         const inner = [{
@@ -102,30 +79,18 @@ export const proof = {
                 handler: inner,
             }];
         const [state, code] = run(outer)(['sub', 'help']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('ping')) {
-            throw 'expected inner command in help';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('ping'), 'expected inner command in help');
     },
     prototypeNameIsUnknownCommand: () => {
         const [state, code] = run(echoCommands)(['toString']);
-        if (code !== 1) {
-            throw ['expected exit 1 for prototype-name command', code];
-        }
-        if (!state.stderr.includes('unknown command')) {
-            throw 'expected unknown-command error in stderr';
-        }
+        assertEq(code, 1, ['expected exit 1 for prototype-name command', code]);
+        assert(state.stderr.includes('unknown command'), 'expected unknown-command error in stderr');
     },
     helpPrototypeSafe: () => {
         const [state, code] = run(echoCommands)(['help', 'toString']);
-        if (code !== 0) {
-            throw ['expected exit 0, not a throw', code];
-        }
-        if (!state.stdout.includes('echo')) {
-            throw 'expected top-level help for unknown target';
-        }
+        assertEq(code, 0, ['expected exit 0, not a throw', code]);
+        assert(state.stdout.includes('echo'), 'expected top-level help for unknown target');
     },
     helpWithTarget: () => {
         const inner = [{
@@ -139,14 +104,8 @@ export const proof = {
                 handler: inner,
             }];
         const [state, code] = run(outer)(['help', 'sub']);
-        if (code !== 0) {
-            throw ['expected exit 0', code];
-        }
-        if (!state.stdout.includes('ping')) {
-            throw 'expected inner command in help';
-        }
-        if (state.stdout.includes('Subcommand group')) {
-            throw 'expected inner help, not outer';
-        }
+        assertEq(code, 0, ['expected exit 0', code]);
+        assert(state.stdout.includes('ping'), 'expected inner command in help');
+        assert(!(state.stdout.includes('Subcommand group')), 'expected inner help, not outer');
     },
 };

package/{fs → fjs}/common/monoid/module.f.d.ts

@@ -1,11 +1,13 @@
 /**
  * Monoids: the `Monoid<T>` algebraic structure (identity plus associative
- * binary operation) and `repeat`, which applies the operation `n` times using
- * exponentiation by squaring.
+ * binary operation), `repeat`, which applies the operation `n` times using
+ * exponentiation by squaring, and `fold`, which applies it across every element
+ * of a list.
  *
  * @module
  */
 import type { Fold, Reduce } from '../../types/function/operator/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
 /**
  * Represents a monoid, an algebraic structure with a binary operation
  * and an identity (neutral) element.
@@ -80,3 +82,45 @@ export type Monoid<T> = {
  * ```
  */
 export declare const repeat: <T>({ identity, operation }: Monoid<T>) => Fold<bigint, T>;
+/**
+ * Reduces a `List<T>` with the monoid's associative `operation`, seeded at its
+ * `identity`. An empty list folds to `identity`.
+ *
+ * `fold` is the reduction companion of {@link repeat}: where `repeat` applies
+ * the operation a fixed number of times to a single element, `fold` applies it
+ * across every element of a list. Together they let list reductions such as
+ * `sum`, `product`, and string `concat` be expressed directly as monoid folds,
+ * so the identity paired with each operation is stated once at the call site
+ * instead of hand-seeding a raw `reduce`.
+ *
+ * Like `repeat`, `fold` applies the operation **accumulator-first**:
+ * `operation(accumulator)(element)`, seeded at `identity`, so
+ * `[a, b, c]` folds to `((identity op a) op b) op c`. Left-to-right order is
+ * therefore preserved and `fold` is correct for non-commutative monoids (e.g.
+ * string concatenation as `a => b => a + b`). `list.reduce` calls its reducer
+ * element-first, so the operation is `flip`ped before it is handed over.
+ *
+ * @template T The type of the elements in the monoid.
+ * @param monoid The monoid structure, including the identity and binary operation.
+ * @returns A function that reduces a `List<T>` to a single `T`.
+ *
+ * @example
+ *
+ * ```ts
+ * const add: Monoid<number> = {
+ *     identity: 0,
+ *     operation: a => b => a + b,
+ * };
+ *
+ * fold(add)([1, 2, 3, 4]) // 10
+ * fold(add)([])           // 0
+ *
+ * const concat: Monoid<string> = {
+ *     identity: '',
+ *     operation: a => b => a + b,
+ * };
+ *
+ * fold(concat)(['a', 'b', 'c']) // 'abc' — order preserved
+ * ```
+ */
+export declare const fold: <T>({ identity, operation }: Monoid<T>) => (list: List<T>) => T;

package/fjs/common/monoid/module.f.js

@@ -0,0 +1,88 @@
+import { reduce } from '../../types/list/module.f.js';
+import { flip } from '../../types/function/module.f.js';
+/**
+ * Repeats a monoid operation `n` times on the given element `a`.
+ * This function efficiently performs the operation using exponentiation by squaring.
+ *
+ * @template T The type of the elements in the monoid.
+ * @param monoid The monoid structure, including the identity and binary operation.
+ * @returns A function that takes an element `a` and a repetition count `n`,
+ * and returns the result of applying the operation `n` times.
+ *
+ * See also {@link https://en.wikipedia.org/wiki/Exponentiation_by_squaring}.
+ *
+ * @example
+ *
+ * ```ts
+ * const add: Monoid<number> = {
+ *     identity: 0,
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultAdd = repeat(add)(10n)(2) // 20
+ *
+ * const concat: Monoid<string> = {
+ *     identity: '',
+ *     operation: a => b => a + b,
+ * };
+ *
+ * const resultConcat = repeat(concat)(3n)('ha') // 'hahaha'
+ * ```
+ */
+export const repeat = ({ identity, operation }) => n => a => {
+    let ai = a;
+    let ni = n;
+    let result = identity;
+    while (true) {
+        if ((ni & 1n) !== 0n) {
+            result = operation(result)(ai);
+        }
+        ni >>= 1n;
+        if (ni === 0n) {
+            return result;
+        }
+        ai = operation(ai)(ai);
+    }
+};
+/**
+ * Reduces a `List<T>` with the monoid's associative `operation`, seeded at its
+ * `identity`. An empty list folds to `identity`.
+ *
+ * `fold` is the reduction companion of {@link repeat}: where `repeat` applies
+ * the operation a fixed number of times to a single element, `fold` applies it
+ * across every element of a list. Together they let list reductions such as
+ * `sum`, `product`, and string `concat` be expressed directly as monoid folds,
+ * so the identity paired with each operation is stated once at the call site
+ * instead of hand-seeding a raw `reduce`.
+ *
+ * Like `repeat`, `fold` applies the operation **accumulator-first**:
+ * `operation(accumulator)(element)`, seeded at `identity`, so
+ * `[a, b, c]` folds to `((identity op a) op b) op c`. Left-to-right order is
+ * therefore preserved and `fold` is correct for non-commutative monoids (e.g.
+ * string concatenation as `a => b => a + b`). `list.reduce` calls its reducer
+ * element-first, so the operation is `flip`ped before it is handed over.
+ *
+ * @template T The type of the elements in the monoid.
+ * @param monoid The monoid structure, including the identity and binary operation.
+ * @returns A function that reduces a `List<T>` to a single `T`.
+ *
+ * @example
+ *
+ * ```ts
+ * const add: Monoid<number> = {
+ *     identity: 0,
+ *     operation: a => b => a + b,
+ * };
+ *
+ * fold(add)([1, 2, 3, 4]) // 10
+ * fold(add)([])           // 0
+ *
+ * const concat: Monoid<string> = {
+ *     identity: '',
+ *     operation: a => b => a + b,
+ * };
+ *
+ * fold(concat)(['a', 'b', 'c']) // 'abc' — order preserved
+ * ```
+ */
+export const fold = ({ identity, operation }) => reduce(flip(operation))(identity);

package/fjs/common/monoid/proof.f.d.ts

@@ -0,0 +1,9 @@
+export declare const proof: {
+    numberAdd: () => void;
+    stringConcat: () => void;
+    fold: {
+        nonEmpty: () => void;
+        order: () => void;
+        empty: () => void;
+    };
+};

package/fjs/common/monoid/proof.f.js

@@ -0,0 +1,48 @@
+import { repeat, fold } from "./module.f.js";
+import { assertEq } from '../../asserts/module.f.js';
+export const proof = {
+    numberAdd: () => {
+        const add = {
+            identity: 0,
+            operation: a => b => a + b,
+        };
+        const resultAdd = repeat(add)(10n)(2); // 20
+        assertEq(resultAdd, 20);
+        const id = repeat(add)(0n)(42);
+        assertEq(id, 0);
+    },
+    stringConcat: () => {
+        const concat = {
+            identity: '',
+            operation: a => b => a + b,
+        };
+        const resultConcat = repeat(concat)(3n)('ha'); // 'hahaha'
+        assertEq(resultConcat, 'hahaha');
+    },
+    fold: {
+        nonEmpty: () => {
+            const add = {
+                identity: 0,
+                operation: a => b => a + b,
+            };
+            assertEq(fold(add)([1, 2, 3, 4]), 10);
+        },
+        order: () => {
+            // a non-commutative monoid: `fold` must preserve left-to-right order
+            // (`((('' + 'a') + 'b') + 'c')`), not reverse it to `'cba'`.
+            const concat = {
+                identity: '',
+                operation: a => b => a + b,
+            };
+            assertEq(fold(concat)(['a', 'b', 'c']), 'abc');
+        },
+        empty: () => {
+            const concat = {
+                identity: '',
+                operation: a => b => a + b,
+            };
+            // an empty list folds to the identity
+            assertEq(fold(concat)([]), '');
+        },
+    }
+};

package/{fs → fjs}/crypto/hmac/proof.f.js

@@ -6,29 +6,21 @@ import { hmac } from './module.f.js';
 export const proof = {
     example: () => {
         const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n)) {
-            throw r;
-        }
+        assertEq(r, vec(256n)(0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n));
     },
     sha256: () => {
         const r = hmac(sha256)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (uint(r) !== 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n) {
-            throw r;
-        }
+        assertEq(uint(r), 0xf7bc83f430538424b13298e6aa6fb143ef4d59a14946175997479dbc2d1a3cd8n, r);
     },
     sha384: () => {
         const k = vec(384n)(0n);
         const m = vec(904n)(0x0101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010101010069c7548c21d0dfea6b9a51c9ead4e27c33d3b3f180316e5bcab92c933f0e4dbc9a9083505bc92276aec4be312696ef7bf3bf603f4bbd381196a029f340585312n);
         const r = hmac(sha384)(k)(m);
-        if (r !== vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban)) {
-            throw uint(r).toString(16);
-        }
+        assertEq(r, vec(384n)(0x8f858157ce005cd52fd8e8f1a46b55e6cfae21c8c183d9c2f7504bedf450609edd7d3c6171dc0bdd2d2444faa28f18ban), uint(r).toString(16));
     },
     sha512: () => {
         const r = hmac(sha512)(utf8('key'))(utf8('The quick brown fox jumps over the lazy dog'));
-        if (r !== vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an)) {
-            throw r;
-        }
+        assertEq(r, vec(512n)(0xb42af09057bac1e2d41708e48a902e09b5ff7f12ab428a4fe86653c73dd248fb82f948a549f7b791a5b41915ee4d1ec3935357e4e2317250d0372afa2ebeeb3an));
     },
     // RFC 4231 Test Case 6: key (131 bytes of 0xaa = 1048 bits) exceeds SHA-256 block size (512 bits),
     // so the key is first compressed via the hash function before use.