functionalscript 0.17.0 → 0.18.0

package/fs/io/module.js

@@ -10,12 +10,46 @@ import http from 'node:http';
 import childProcess from 'node:child_process';
 import fs from 'node:fs';
 import process from 'node:process';
-import { fromIo, run } from "./module.f.js";
 import { concat } from "../path/module.f.js";
+import { once } from 'node:events';
+import { fromIo, runProgram } from "./module.f.js";
 import { error, ok } from "../types/result/module.f.js";
+import { fromVec } from "../types/uint8array/module.f.js";
 const prefix = 'file:///';
 const { now } = Date;
+/** Maps `WriteConsoles` names to the corresponding Node.js writable streams. */
+const streams = {
+    stdout: process.stdout,
+    stderr: process.stderr,
+};
+/**
+ * Writes `data` to `stream` respecting Node.js backpressure.
+ *
+ * `stream.write()` returns `false` when the internal buffer is full; the data
+ * is already buffered at that point (no retry needed) but the caller must not
+ * issue more writes until the `'drain'` event fires. Waiting here throttles the
+ * producer to the speed of the OS consumer, preventing unbounded memory growth
+ * when many large messages arrive faster than they can be flushed.
+ *
+ * When the buffer is not full `write()` returns `true` and we return
+ * immediately, so large computations with occasional prints never stall.
+ *
+ * @see {@link https://nodejs.org/api/stream.html#writablewritechunk}
+ */
+const writeAll = async (stream, data) => {
+    if (!stream.write(data)) {
+        await once(stream, 'drain');
+    }
+};
 export const asyncImport = (v) => import(__rewriteRelativeImportExtension(v));
+export const tryCatch = f => {
+    try {
+        return ok(f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
 export const io = {
     console,
     fs,
@@ -27,14 +61,7 @@ export const io = {
     },
     performance,
     fetch,
-    tryCatch: f => {
-        try {
-            return ok(f());
-        }
-        catch (e) {
-            return error(e);
-        }
-    },
+    tryCatch,
     asyncTryCatch: async (f) => {
         try {
             return ok(await f());
@@ -61,13 +88,7 @@ export const io = {
         }
         return { result, duration: after - before };
     },
+    write: (stream, data) => writeAll(streams[stream], fromVec(data)),
 };
-export const legacyRun = run(io);
-export const ioRun = (io) => {
-    const r = fromIo(io);
-    const { argv, env } = io.process;
-    const options = { args: argv.slice(2), env };
-    return p => r(p(options));
-};
-const effectRun = ioRun(io);
+const effectRun = runProgram(io)(io.process.argv.slice(2));
 export default effectRun;

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

@@ -20,3 +20,9 @@ export declare const normalize: Unary<string, string>;
  * Concatenates two path fragments and returns a normalized path.
  */
 export declare const concat: Reduce<string>;
+/**
+ * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
+ * if it does not start with `base` or `base` is empty.
+ * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
+ */
+export declare const relativize: (base: string, path: string) => string;

package/fs/path/module.f.js

@@ -46,3 +46,9 @@ export const concat = a => b => {
     const s = stringConcat([a, '/', b]);
     return normalize(s);
 };
+/**
+ * Returns `path` relative to `base` with a `./` prefix, or `path` unchanged
+ * if it does not start with `base` or `base` is empty.
+ * E.g. `relativize('/repo', '/repo/fs/a.ts')` → `'./fs/a.ts'`.
+ */
+export const relativize = (base, path) => base !== '' && path.startsWith(base) ? `.${path.slice(base.length)}` : path;

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

@@ -1,5 +1,3 @@
-declare const _default: {
-    normalize: (() => void)[];
-    concat: (() => void)[];
-};
-export default _default;
+export declare const normalizeTest: (() => void)[];
+export declare const concatTest: (() => void)[];
+export declare const relativizeTest: (() => void)[];

package/fs/path/test.f.js

@@ -1,49 +1,67 @@
-import { concat, normalize } from "./module.f.js";
-export default {
-    normalize: [
-        () => {
-            const norm = normalize("dir/file.json");
-            if (norm !== "dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("dir//file.json");
-            if (norm !== "dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("../../dir/file.json");
-            if (norm !== "../../dir/file.json") {
-                throw norm;
-            }
-        },
-        () => {
-            const norm = normalize("../../dir/../file.json");
-            if (norm !== "../../file.json") {
-                throw norm;
-            }
-        },
-    ],
-    concat: [
-        () => {
-            const c = concat("a")("b");
-            if (c !== "a/b") {
-                throw c;
-            }
-        },
-        () => {
-            const c = concat("a///b/")("c");
-            if (c !== "a/b/c") {
-                throw c;
-            }
-        },
-        () => {
-            const c = concat("a/../b/..")("c");
-            if (c !== "c") {
-                throw c;
-            }
-        },
-    ]
-};
+import { concat, normalize, relativize } from "./module.f.js";
+export const normalizeTest = [
+    () => {
+        const norm = normalize("dir/file.json");
+        if (norm !== "dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("dir//file.json");
+        if (norm !== "dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("../../dir/file.json");
+        if (norm !== "../../dir/file.json") {
+            throw norm;
+        }
+    },
+    () => {
+        const norm = normalize("../../dir/../file.json");
+        if (norm !== "../../file.json") {
+            throw norm;
+        }
+    },
+];
+export const concatTest = [
+    () => {
+        const c = concat("a")("b");
+        if (c !== "a/b") {
+            throw c;
+        }
+    },
+    () => {
+        const c = concat("a///b/")("c");
+        if (c !== "a/b/c") {
+            throw c;
+        }
+    },
+    () => {
+        const c = concat("a/../b/..")("c");
+        if (c !== "c") {
+            throw c;
+        }
+    },
+];
+export const relativizeTest = [
+    () => {
+        const r = relativize('/repo', '/repo/fs/a.ts');
+        if (r !== './fs/a.ts') {
+            throw r;
+        }
+    },
+    () => {
+        const r = relativize('/repo', '/other/a.ts');
+        if (r !== '/other/a.ts') {
+            throw r;
+        }
+    },
+    () => {
+        const r = relativize('', './fs/a.ts');
+        if (r !== './fs/a.ts') {
+            throw r;
+        }
+    },
+];

package/fs/text/sgr/module.f.d.ts

@@ -5,6 +5,8 @@
  * @module
  */
 import type { Io, Writable } from "../../io/module.f.ts";
+import { type Write, type WriteConsoles, type NodeProgramOptions } from '../../types/effects/node/module.f.ts';
+import { type Effect } from '../../types/effects/module.f.ts';
 export declare const backspace: string;
 type End = 'm';
 type Csi = (code: number | string) => string;
@@ -44,7 +46,7 @@ export type WriteText = (text: string) => WriteText;
 export declare const createConsoleText: (stdout: Stdout) => WriteText;
 export type CsiConsole = (s: string) => void;
 /**
- * Creates a TTY-aware console function.
+ * Creates a TTY-aware console function. Appends `\n` to each string before writing.
  *
  * For TTY destinations, ANSI SGR sequences are preserved.
  * For non-TTY destinations, ANSI SGR sequences are stripped.
@@ -57,4 +59,10 @@ export declare const console: ({ fs: { writeSync } }: Io) => (w: Writable) => Cs
 export declare const stdio: (io: Io) => CsiConsole;
 /** Writes to process stderr using a TTY-aware CSI console. */
 export declare const stderr: (io: Io) => CsiConsole;
+/**
+ * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
+ * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.
+ * Does NOT append `\n` — callers are responsible for line termination.
+ */
+export declare const csiWrite: ({ std }: NodeProgramOptions) => (stream: WriteConsoles) => (s: string) => Effect<Write, void>;
 export {};

package/fs/text/sgr/module.f.js

@@ -4,6 +4,9 @@
  *
  * @module
  */
+import { write } from "../../types/effects/node/module.f.js";
+import {} from "../../types/effects/module.f.js";
+import { utf8 } from "../module.f.js";
 export const backspace = '\x08';
 const begin = '\x1b[';
 /**
@@ -46,8 +49,9 @@ export const createConsoleText = (stdout) => {
     };
     return f('');
 };
+const str = (isTTY) => (s) => isTTY ? s : s.replace(/\x1b\[[0-9;]*m/g, '');
 /**
- * Creates a TTY-aware console function.
+ * Creates a TTY-aware console function. Appends `\n` to each string before writing.
  *
  * For TTY destinations, ANSI SGR sequences are preserved.
  * For non-TTY destinations, ANSI SGR sequences are stripped.
@@ -56,12 +60,19 @@ export const createConsoleText = (stdout) => {
  * @returns A function that targets a writable stream.
  */
 export const console = ({ fs: { writeSync } }) => (w) => {
-    const { isTTY } = w;
-    return isTTY
-        ? (s) => writeSync(w.fd, s + '\n')
-        : (s) => writeSync(w.fd, s.replace(/\x1b\[[0-9;]*m/g, '') + '\n');
+    const toStr = str(w.isTTY);
+    return (s) => writeSync(w.fd, toStr(s) + '\n');
 };
 /** Writes to process stdout using a TTY-aware CSI console. */
 export const stdio = (io) => console(io)(io.process.stdout);
 /** Writes to process stderr using a TTY-aware CSI console. */
 export const stderr = (io) => console(io)(io.process.stderr);
+/**
+ * Effect-based TTY-aware write. Strips ANSI SGR sequences when the target
+ * stream is not a TTY, then encodes to UTF-8 and emits a `Write` effect.
+ * Does NOT append `\n` — callers are responsible for line termination.
+ */
+export const csiWrite = ({ std }) => (stream) => {
+    const toStr = str(std[stream].isTTY);
+    return (s) => write(stream, utf8(toStr(s)));
+};

package/fs/types/effects/node/module.f.d.ts

@@ -1,12 +1,3 @@
-/**
- * Node.js effect operations: filesystem (`mkdir`, `readFile`, `readdir`,
- * `writeFile`, `rm`, `access`), networking (`fetch`, `createServer`, `listen`),
- * subprocess `exec`, console (`log`, `error`), `import_`, `now`, `sandbox`, `forever`,
- * and `all`/`both` parallelism; defines the `NodeOp`/`NodeProgram` types used
- * by the Node runner.
- *
- * @module
- */
 import type { Vec } from '../../bit_vec/module.f.ts';
 import type { Nominal } from '../../nominal/module.f.ts';
 import type { Result } from '../../result/module.f.ts';
@@ -58,11 +49,6 @@ export declare const exec: Func<Exec>;
 export type Access = readonly ['access', (path: string) => IoResult<void>];
 export declare const access: Func<Access>;
 export type Fs = Mkdir | ReadFile | Readdir | WriteFile | Rm | Exec | Access;
-export type Error = ['error', (message: string) => void];
-export declare const error: Func<Error>;
-export type Log = ['log', (message: string) => void];
-export declare const log: Func<Log>;
-export type Console = Log | Error;
 export type Server = Nominal<'server', `160855c4f69310fece3273c1853ac32de43dee1eb41bf59d821917f8eebe9272`, unknown>;
 export type Headers = {
     readonly [k in string]: string;
@@ -87,10 +73,18 @@ export type Http = CreateServer | Listen;
 export type Forever = ['forever', () => never];
 export declare const forever: Func<Forever>;
 export type Module = {
-    readonly default: unknown;
+    readonly [k in string]: unknown;
 };
 export type Import = ['import', (path: string) => IoResult<Module>];
 export declare const import_: Func<Import>;
+export type WriteConsoles = 'stdout' | 'stderr';
+export type Write = readonly ['write', (stream: WriteConsoles, data: Vec) => void];
+export declare const write: Func<Write>;
+export type Console = (s: string) => Effect<Write, void>;
+/** Writes a line to `stdout`. Replaces the retired `Log` effect. */
+export declare const log: Console;
+/** Writes a line to `stderr`. Replaces the retired `Error` effect. */
+export declare const error: Console;
 export type Now = readonly ['now', () => number];
 export declare const now: Func<Now>;
 export type SandboxResult<T> = {
@@ -122,7 +116,7 @@ export type Sandbox = readonly ['sandbox', <T>(f: () => T) => SandboxResult<T>];
  * @see {@link SandboxResult}
  */
 export declare const sandbox: Func<Sandbox>;
-export type NodeOp = All | Fetch | Console | Fs | Http | Forever | Import | Now | Sandbox;
+export type NodeOp = All | Fetch | Fs | Http | Forever | Import | Now | Sandbox | Write;
 export type NodeEffect<T> = Effect<NodeOp, T>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;
 /**
@@ -134,5 +128,11 @@ export type Env = {
 export type NodeProgramOptions = {
     readonly args: readonly string[];
     readonly env: Env;
+    readonly std: {
+        readonly [k in WriteConsoles]: {
+            readonly isTTY: boolean;
+        };
+    };
 };
-export type NodeProgram = (options: NodeProgramOptions) => Effect<NodeOp, number>;
+export type Program<O extends Operation> = (options: NodeProgramOptions) => Effect<O, number>;
+export type NodeProgram = Program<NodeOp>;

package/fs/types/effects/node/module.f.js

@@ -1,3 +1,13 @@
+/**
+ * Node.js effect operations: filesystem (`mkdir`, `readFile`, `readdir`,
+ * `writeFile`, `rm`, `access`), networking (`fetch`, `createServer`, `listen`),
+ * subprocess `exec`, `log`/`error` (wrappers over `write`), `import_`, `now`,
+ * `sandbox`, `forever`, and `all`/`both` parallelism; defines the
+ * `NodeOp`/`NodeProgram` types used by the Node runner.
+ *
+ * @module
+ */
+import { utf8 } from "../../../text/module.f.js";
 import { do_ } from "../module.f.js";
 const doAll = do_('all');
 /**
@@ -17,12 +27,20 @@ export const writeFile = do_('writeFile');
 export const rm = do_('rm');
 export const exec = do_('exec');
 export const access = do_('access');
-export const error = do_('error');
-export const log = do_('log');
 export const createServer = do_('createServer');
 export const listen = do_('listen');
 export const forever = do_('forever');
 export const import_ = do_('import');
+export const write = do_('write');
+/**
+ * Encodes `s + '\n'` as UTF-8 and emits a `Write` effect to `stream`.
+ * Shared implementation for `log` and `error`.
+ */
+const writeString = (stream) => (s) => write(stream, utf8(s + '\n'));
+/** Writes a line to `stdout`. Replaces the retired `Log` effect. */
+export const log = writeString('stdout');
+/** Writes a line to `stderr`. Replaces the retired `Error` effect. */
+export const error = writeString('stderr');
 export const now = do_('now');
 /**
  * Runs a plain synchronous function in an isolated, measured environment.

package/fs/types/effects/node/test.f.js

@@ -64,11 +64,11 @@ export default {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (tmp === undefined || isVec(tmp)) {
+            if (typeof tmp !== 'object') {
                 throw state.root;
             }
             const cache = tmp.cache;
-            if (cache === undefined || isVec(cache)) {
+            if (typeof cache !== 'object') {
                 throw tmp;
             }
         },
@@ -294,7 +294,7 @@ export default {
                 throw result;
             }
             const tmp = state.root.tmp;
-            if (tmp === undefined || isVec(tmp)) {
+            if (typeof tmp !== 'object') {
                 throw state.root;
             }
             if (tmp.cache !== undefined) {
@@ -333,8 +333,11 @@ export default {
         }
     },
     sandbox: {
+        // Virtual `sandbox` is now a pass-through: the function is expected
+        // to return a `SandboxResult` directly. Fixtures dictate the result
+        // (and `duration`) instead of the runner measuring.
         ok: () => {
-            const [_, { result, duration }] = virtual(emptyState)(sandbox(() => 42));
+            const [_, { result, duration }] = virtual(emptyState)(sandbox(() => ({ result: ['ok', 42], duration: 0 })));
             if (result[0] !== 'ok') {
                 throw result;
             }
@@ -347,7 +350,7 @@ export default {
         },
         error: () => {
             const err = new Error('fail');
-            const [_, { result }] = virtual(emptyState)(sandbox(() => { throw err; }));
+            const [_, { result }] = virtual(emptyState)(sandbox(() => ({ result: ['error', err], duration: 0 })));
             if (result[0] !== 'error') {
                 throw result;
             }

package/fs/types/effects/node/virtual/module.f.d.ts

@@ -1,8 +1,17 @@
 import { type Vec } from '../../../bit_vec/module.f.ts';
 import { type RunInstance } from '../../mock/module.f.ts';
-import type { NodeOp } from '../module.f.ts';
+import type { Module, NodeOp } from '../module.f.ts';
+/**
+ * In-memory JS module entry. When `import_` is called on the path, the
+ * function is invoked and its return value is the module value (with a
+ * `default` export and optional named exports). Using a function (not a
+ * plain value) lets the entry be distinguished from `Vec`/`Dir` at runtime
+ * via `typeof === 'function'`, and lets the fixture compute the module on
+ * each import for closures/state.
+ */
+export type JsModule = () => Module;
 export type Dir = {
-    readonly [name in string]?: Dir | Vec;
+    readonly [name in string]?: Dir | Vec | JsModule;
 };
 export type State = {
     stdout: string;

package/fs/types/effects/node/virtual/module.f.js

@@ -3,8 +3,9 @@
  *
  * @module
  */
-import { todo } from "../../../../dev/module.f.js";
+import { assert, todo } from "../../../../dev/module.f.js";
 import { parse } from "../../../../path/module.f.js";
+import { utf8ToString } from "../../../../text/module.f.js";
 import { isVec } from "../../../bit_vec/module.f.js";
 import { error, ok } from "../../../result/module.f.js";
 import { run } from "../../mock/module.f.js";
@@ -22,7 +23,7 @@ const operation = (op) => {
         }
         const [first, ...rest] = path;
         const subDir = dir[first];
-        if (subDir === undefined || isVec(subDir)) {
+        if (typeof subDir !== 'object') {
             return op(dir, path);
         }
         const [newSubDir, r] = f(subDir, rest);
@@ -54,11 +55,24 @@ const readFile = readOperation((dir, path) => {
         return readFileError;
     }
     const file = dir[path[0]];
+    if (typeof file === 'function') {
+        throw new Error(`'${path[0]}' is a JsModule; readFile not supported`);
+    }
     if (!isVec(file)) {
         return error(`'${path[0]}' is not a file`);
     }
     return ok(file);
 });
+const import_ = readOperation((dir, path) => {
+    if (path.length !== 1) {
+        return error('no such file');
+    }
+    const entry = dir[path[0]];
+    if (typeof entry !== 'function') {
+        return error(`'${path[0]}' is not a JsModule`);
+    }
+    return ok(entry());
+});
 const writeFileError = error('invalid file');
 const writeFile = (payload) => operation((dir, path) => {
     if (path.length !== 1) {
@@ -85,7 +99,7 @@ const readdir = (base, recursive) => readOperation((dir, path) => {
             if (content === undefined) {
                 continue;
             }
-            const isFile = isVec(content);
+            const isFile = typeof content !== 'object';
             result = [...result, { name, parentPath, isFile }];
             if (!isFile && recursive) {
                 result = [...result, ...f(`${parentPath}/${name}`, content)];
@@ -113,13 +127,12 @@ const rm = operation((dir, path) => {
     if (entry === undefined) {
         return [dir, error('no such file')];
     }
-    if (!isVec(entry)) {
+    if (typeof entry === 'object') {
         return [dir, error('is a directory')];
     }
     const { [name]: _, ...rest } = dir;
     return [rest, okVoid];
 });
-const console = (name) => (state, payload) => [{ ...state, [name]: `${state[name]}${payload}\n` }, undefined];
 const map = {
     all: (state, ...a) => {
         let e = [];
@@ -130,8 +143,6 @@ const map = {
         }
         return [state, e];
     },
-    error: console('stderr'),
-    log: console('stdout'),
     fetch: (state, url) => {
         const result = state.internet[url];
         return result === undefined ? [state, error('not found')] : [state, ok(result)];
@@ -141,22 +152,24 @@ const map = {
     readdir: (state, path, { recursive }) => readdir(path, recursive === true)(state, path),
     writeFile: (state, path, payload) => writeFile(payload)(state, path),
     access,
-    import: todo,
+    import: import_,
     rm,
     exec: todo,
     createServer: todo,
     listen: todo,
     forever: todo,
     now: (state) => [state, state.epochNs],
-    sandbox: (state, f) => {
-        let result;
-        try {
-            result = ok(f());
-        }
-        catch (e) {
-            result = error(e);
-        }
-        return [state, { result, duration: 0 }];
+    // Virtual sandbox is a pass-through: the fixture's test function is
+    // expected to return a `SandboxResult` directly (encoding pass/fail and a
+    // chosen duration), so the handler invokes it without try/catch or clock
+    // reads. This makes test outcomes deterministic — fixtures dictate the
+    // result instead of the runner measuring real execution. A genuine
+    // exception in a fixture propagates loudly as a bug in the fixture.
+    // See: issues/156-tf-virtual-tests.md
+    sandbox: (state, f) => [state, f()],
+    write: (state, stream, data) => {
+        const s = utf8ToString(data);
+        return [{ ...state, [stream]: `${state[stream]}${s}` }, undefined];
     },
 };
 export const virtual = run(map);

package/fs/types/function/compare/module.f.d.ts

@@ -6,6 +6,7 @@
 import type { Index3, Index5, Array2 } from '../../array/module.f.ts';
 export type Sign = -1 | 0 | 1;
 export type Compare<T> = (_: T) => Sign;
+export type Cmp<T> = (a: T) => Compare<T>;
 export declare const index3: <T>(cmp: Compare<T>) => (value: T) => Index3;
 export declare const index5: <T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5;
 export type Cmp1 = boolean | string | number | bigint;
@@ -23,3 +24,14 @@ export type Cmp2<A, B> = [
     B
 ] extends [bigint, bigint] ? bigint : never;
 export declare const cmp: <A extends Cmp1>(a: A) => <B extends Cmp2<A, B>>(b: B) => Sign;
+/**
+ * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
+ * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a
+ * hit it returns the matching index; on a miss it returns the converged lower
+ * bound `b` (the insertion point), which may equal `len`.
+ *
+ * `probe` must be monotonic over `[0, len)`: scanning indices left to right its
+ * result is non-increasing — a run of `1`s, then `0`s, then `-1`s. A
+ * non-monotonic probe yields an undefined position.
+ */
+export declare const bsearch: (len: number) => (probe: (mid: number) => Sign) => number;

package/fs/types/function/compare/module.f.js

@@ -4,3 +4,36 @@ export const index5 = cmp => ([v0, v1]) => {
     return (_0 <= 0 ? _0 + 1 : cmp(v1) + 3);
 };
 export const cmp = (a) => (b) => a < b ? -1 : a > b ? 1 : 0;
+/**
+ * Binary search over `[0, len)`. `probe(mid)` returns the sign of the search
+ * key relative to the element at `mid` (`-1` before, `0` at, `1` after). On a
+ * hit it returns the matching index; on a miss it returns the converged lower
+ * bound `b` (the insertion point), which may equal `len`.
+ *
+ * `probe` must be monotonic over `[0, len)`: scanning indices left to right its
+ * result is non-increasing — a run of `1`s, then `0`s, then `-1`s. A
+ * non-monotonic probe yields an undefined position.
+ */
+export const bsearch = (len) => (probe) => {
+    let b = 0;
+    let e = len - 1;
+    while (true) {
+        if (e < b) {
+            return b;
+        }
+        const mid = b + (e - b >> 1);
+        switch (probe(mid)) {
+            case -1: {
+                e = mid - 1;
+                break;
+            }
+            case 0: {
+                return mid;
+            }
+            case 1: {
+                b = mid + 1;
+                break;
+            }
+        }
+    }
+};

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

@@ -0,0 +1,10 @@
+export declare const joinTest: () => void;
+export declare const concatTest: () => void;
+export declare const logicalNotTest: () => void;
+export declare const strictEqualTest: () => void;
+export declare const additionTest: () => void;
+export declare const minTest: () => void;
+export declare const maxTest: () => void;
+export declare const incrementTest: () => void;
+export declare const foldToScanTest: () => void;
+export declare const reduceToScanTest: () => void;