functionalscript 0.37.0 → 0.39.0

package/{fs → fjs}/effects/node/memory/proof.js

@@ -6,30 +6,24 @@
 import { asyncRun } from '../../module.js';
 import { asNominal, create, read, write, } from '../../memory/module.f.js';
 import { memoryOperationMap, run } from './module.js';
+import { assert, assertEq } from '../../../asserts/module.f.js';
+import { step } from '../../module.f.js';
 export const proof = {
     nodeInterpreter: async () => {
-        const result = await run(create(1).step(key => write(key, 2).step(() => read(key))));
-        if (result !== 2) {
-            throw result;
-        }
+        const x = step(create(1), key => step(write(key, 2), () => read(key)));
+        assertEq(await run(x), 2);
     },
     reusedOperationMapPersists: async () => {
         const runner = asyncRun(memoryOperationMap());
         const key = await runner(create(1));
         await runner(write(key, 2));
         const result = await runner(read(key));
-        if (result !== 2) {
-            throw result;
-        }
+        assertEq(result, 2);
     },
     missingKeyThrows: async () => {
         const key = asNominal('missing');
         const result = await run(read(key)).then(() => undefined, error => error);
-        if (!(result instanceof Error)) {
-            throw result;
-        }
-        if (result.message !== 'memory key not found: missing') {
-            throw result;
-        }
+        assert(result instanceof Error, result);
+        assertEq(result.message, 'memory key not found: missing', result);
     },
 };

package/{fs → fjs}/effects/node/module.d.ts

@@ -15,6 +15,6 @@ export declare const runEffect: (p: NodeProgram) => Promise<number>;
  * that control never returns to the caller — the process terminates.
  *
  * A `bin` script can simply
- * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ * `import { run } from '.../fjs/effects/node/module.js'; await run(main)`.
  */
 export declare const run: (p: NodeProgram) => Promise<never>;

package/{fs → fjs}/effects/node/module.f.d.ts

@@ -218,7 +218,7 @@ export declare const sandbox: Func<Sandbox>;
  * If `p` is a real `Promise`, it is awaited and rejections propagate as
  * throws. If `p` is any other value it is returned as-is. Plain thenables
  * (objects with a `.then` method that are not `instanceof Promise`) are
- * treated as ordinary values — not awaited. See `fs/dev/tf/README.md`.
+ * treated as ordinary values — not awaited. See `fjs/dev/tf/README.md`.
  */
 export type Await = readonly ['await', (p: unknown) => readonly [unknown]];
 export declare const awaitIfPromise: (p: unknown) => Effect<Await, unknown>;
@@ -247,7 +247,7 @@ export type NodeEffect<T> = Effect<NodeOp, T>;
 /**
  * Writes an error line to `stderr` and yields exit code `1`. The canonical
  * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
- * compose `error(s).step(() => pure(n))` directly.
+ * compose `mapStep(error(s), () => n)` directly.
  */
 export declare const errorExit: (s: string) => Effect<Write, number>;
 export type NodeOperationMap = ToAsyncOperationMap<NodeOp>;

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

@@ -14,7 +14,7 @@ import { codePointListToString } from '../../text/utf16/module.f.js';
 import { reverse } from '../../types/list/module.f.js';
 import { length } from '../../types/bit_vec/module.f.js';
 import { ok, error as resultError, mapOk } from '../../types/result/module.f.js';
-import { do_, okStep, pure } from '../module.f.js';
+import { do_, mapStep, okStep, pure, step } from '../module.f.js';
 /**
  * True if `e` is a "file or directory does not exist" (`ENOENT`) error.
  *
@@ -43,7 +43,7 @@ export const readFile = do_('readFile');
  * on errors (e.g. convert them into domain-specific errors) or `unwrap` at the
  * call site.
  */
-export const readUtf8File = (path) => readFile(path).step(r => pure(mapOk(utf8ToString)(r)));
+export const readUtf8File = (path) => mapStep(readFile(path), mapOk(utf8ToString));
 export const readdir = do_('readdir');
 export const writeFile = do_('writeFile');
 /** Writes a string to `path` as UTF-8 bytes. */
@@ -57,7 +57,7 @@ export const access = do_('access');
 export const createExclusive = do_('createExclusive');
 export const writeBytes = do_('writeBytes');
 const writeLoop = (path) => {
-    const f = (offset, e) => e.step(r => {
+    const f = (offset, e) => step(e, r => {
         if (r === undefined) {
             return pure(ok(undefined));
         }
@@ -69,13 +69,11 @@ const writeLoop = (path) => {
         if ((lenV & 7n) !== 0n) {
             return pure(resultError('invalid buffer size'));
         }
-        return writeBytes(path, offset, v)
-            .step(okStep(() => f(offset + Number(lenV >> 3n), tail)));
+        return step(writeBytes(path, offset, v), okStep(() => f(offset + Number(lenV >> 3n), tail)));
     });
     return f;
 };
-export const writeFromStream = (path, e) => createExclusive(path)
-    .step(okStep(() => writeLoop(path)(0, e)));
+export const writeFromStream = (path, e) => step(createExclusive(path), okStep(() => writeLoop(path)(0, e)));
 export const stat = do_('stat');
 export const createServer = do_('createServer');
 export const listen = do_('listen');
@@ -113,7 +111,7 @@ const lf = 0x0a;
  * rather than the O(n²) of copying a growing array on every byte.
  */
 export const readLine = (stream) => {
-    const loop = (acc) => read(stream).step(b => b === null
+    const loop = (acc) => step(read(stream), b => b === null
         ? pure(acc === null ? null : utf8ListToString(reverse(acc)))
         : b === lf
             ? pure(utf8ListToString(reverse(acc)))
@@ -141,11 +139,11 @@ export const now = do_('now');
  */
 export const sandbox = do_('sandbox');
 const awaitPromise = do_('await');
-export const awaitIfPromise = (p) => awaitPromise(p).step(([x]) => pure(x));
+export const awaitIfPromise = (p) => mapStep(awaitPromise(p), ([x]) => x);
 export const test = do_('test');
 /**
  * Writes an error line to `stderr` and yields exit code `1`. The canonical
  * "fail with a message" program for a `NodeProgram`. For non-`1` exit codes,
- * compose `error(s).step(() => pure(n))` directly.
+ * compose `mapStep(error(s), () => n)` directly.
  */
-export const errorExit = (s) => error(s).step(() => pure(1));
+export const errorExit = (s) => mapStep(error(s), () => 1);

package/{fs → fjs}/effects/node/module.js

@@ -12,8 +12,8 @@ var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExte
  * `fetch`, …).
  *
  * There is deliberately no injectable IO seam here. Effectful programs are
- * tested against the in-memory interpreters in `fs/effects/mock` and
- * `fs/effects/node/virtual`, which interpret the same operations without
+ * tested against the in-memory interpreters in `fjs/effects/mock` and
+ * `fjs/effects/node/virtual`, which interpret the same operations without
  * touching the OS, so a handler-table indirection in this module would have
  * exactly one instance and no consumer — the handlers reference the Node
  * globals directly instead.
@@ -300,6 +300,6 @@ export const runEffect = program => runNodeEffect(program(options));
  * that control never returns to the caller — the process terminates.
  *
  * A `bin` script can simply
- * `import { run } from '.../fs/effects/node/module.js'; await run(main)`.
+ * `import { run } from '.../fjs/effects/node/module.js'; await run(main)`.
  */
 export const run = async (p) => process.exit(await runEffect(p));

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

@@ -63,5 +63,6 @@ export declare const proof: {
     };
     writeFromStream: {
         createExclusiveFails: () => void;
+        invalidBufferSize: () => void;
     };
 };