functionalscript 0.37.0 → 0.39.0

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

@@ -1,32 +1,33 @@
-import { empty, isVec, uint, vec8 } from "../../types/bit_vec/module.f.js";
+import { empty, isVec, uint, vec, vec8 } from "../../types/bit_vec/module.f.js";
 import { utf8, utf8ToString } from "../../text/module.f.js";
-import { decode, pure } from "../module.f.js";
+import { match, pure, step } from "../module.f.js";
 import { both, fetch, mkdir, now, readdir, readFile, readUtf8File, rm, sandbox, writeFile, writeUtf8File, rename, readBytes, randomInt, writeFromStream } from "./module.f.js";
 import { create as memCreate, read as memRead, write as memWrite } from "../memory/module.f.js";
-import { empty as listEmpty } from "../list/module.f.js";
+import { empty as listEmpty, nonEmpty as listNonEmpty } from "../list/module.f.js";
 import { emptyState, virtual } from "./virtual/module.f.js";
+import { assert, assertEq, assertNotNullish } from '../../asserts/module.f.js';
+import { ok } from '../../types/result/module.f.js';
+// Answers the one command the `map` proof below drives. Routing the loop
+// through `match` keeps the `Pure`/`Do` layout out of this module: the map key
+// is the command assertion, and `MatchResult` types the continuation.
+const readHello = match({
+    readFile: path => {
+        assertEq(path, 'hello');
+        return ok(vec8(0x15n));
+    },
+});
 export const proof = {
     map: () => {
-        const e = readFile('hello').step(([k, v]) => {
-            if (k === 'error') {
-                throw v;
-            }
+        const e = step(readFile('hello'), ([k, v]) => {
+            assert(k !== 'error', v);
             return pure(uint(v) * 2n);
         });
         //
-        let d = decode(e);
-        while (!d.done) {
-            if (d.command !== 'readFile') {
-                throw d.command;
-            }
-            if (d.payload[0] !== 'hello') {
-                throw d.payload;
-            }
-            d = decode(d.continuation(['ok', vec8(0x15n)]));
-        }
-        if (d.result !== 0x2an) {
-            throw d.result;
+        let r = readHello(e);
+        while (r[0] === 'cont') {
+            r = readHello(r[2](r[1]));
         }
+        assertEq(r[1], 0x2an);
     },
     fetch: () => {
         const [_, [t, result]] = virtual({
@@ -35,49 +36,29 @@ export const proof = {
                 'https://example.com/data': vec8(0x2an),
             },
         })(fetch('https://example.com/data'));
-        if (t === 'error') {
-            throw result;
-        }
-        if (!isVec(result)) {
-            throw result;
-        }
-        if (uint(result) !== 0x2an) {
-            throw result;
-        }
+        assert(t !== 'error', result);
+        assert(isVec(result), result);
+        assertEq(uint(result), 0x2an, result);
     },
     mkdir: {
         one: () => {
             const [state, [t, result]] = virtual(emptyState)(mkdir('a'));
-            if (t === 'error') {
-                throw result;
-            }
+            assert(t !== 'error', result);
             const a = state.root.a;
-            if (a === undefined || Array.isArray(a)) {
-                throw a;
-            }
+            assert(!(a === undefined || Array.isArray(a)), a);
         },
         rec: () => {
             const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache', { recursive: true }));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
-                throw state.root;
-            }
+            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
             const cache = tmp.cache;
-            if (typeof cache !== 'object' || Array.isArray(cache)) {
-                throw tmp;
-            }
+            assert(!(typeof cache !== 'object' || Array.isArray(cache)), tmp);
         },
         nonRec: () => {
             const [state, [t, result]] = virtual(emptyState)(mkdir('tmp/cache'));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (state.root.tmp !== undefined) {
-                throw state.root.tmp;
-            }
+            assert(t === 'error', result);
+            assertEq(state.root.tmp, undefined);
         }
     },
     readFile: {
@@ -89,42 +70,26 @@ export const proof = {
                 },
             };
             const [state, [t, result]] = virtual(initial)(readFile('hello'));
-            if (t === 'error') {
-                throw result;
-            }
-            if (!isVec(result)) {
-                throw result;
-            }
-            if (uint(result) !== 0x2an) {
-                throw result;
-            }
-            if (state.root.hello === undefined) {
-                throw state.root;
-            }
+            assert(t !== 'error', result);
+            assert(isVec(result), result);
+            assertEq(uint(result), 0x2an, result);
+            assert(state.root.hello !== undefined, state.root);
         },
         nested: () => {
             const [_, [tag, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { cache: [vec8(0x15n)] } }
             })(readFile('tmp/cache'));
-            if (tag === 'error') {
-                throw result;
-            }
-            if (uint(result) !== 0x15n) {
-                throw result;
-            }
+            assert(tag !== 'error', result);
+            assertEq(uint(result), 0x15n, result);
         },
         noSuchFile: () => {
             const [_, [t, result]] = virtual(emptyState)(readFile('hello'));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
         },
         nestedPath: () => {
             const [_, [t, result]] = virtual(emptyState)(readFile('tmp/cache'));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
             if (result.code !== 'ENOENT') {
                 throw result;
             }
@@ -138,12 +103,8 @@ export const proof = {
                 },
             };
             const [_, [t, result]] = virtual(initial)(readFile('smallFile'));
-            if (t === 'error') {
-                throw result;
-            }
-            if (!isVec(result)) {
-                throw result;
-            }
+            assert(t !== 'error', result);
+            assert(isVec(result), result);
         }
     },
     readUtf8File: {
@@ -152,18 +113,12 @@ export const proof = {
                 ...emptyState,
                 root: { hello: [utf8('Hello, world!')] },
             })(readUtf8File('hello'));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (result !== 'Hello, world!') {
-                throw result;
-            }
+            assert(t === 'ok', result);
+            assertEq(result, 'Hello, world!');
         },
         noSuchFile: () => {
             const [_, [t, result]] = virtual(emptyState)(readUtf8File('hello'));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
         },
     },
     readdir: {
@@ -177,9 +132,7 @@ export const proof = {
                     },
                 },
             })(readdir('', { recursive: true }));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const file = result.find(x => x.name === 'file');
             if (file === undefined || file.parentPath !== '' || !file.isFile) {
                 throw `file: ${file}`;
@@ -199,63 +152,35 @@ export const proof = {
                     },
                 },
             })(readdir('', {}));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (result.length !== 2) {
-                throw result;
-            }
-            const file = result.find(x => x.name === 'file');
-            if (file === undefined) {
-                throw file;
-            }
-            const dir = result.find(x => x.name === 'dir');
-            if (dir === undefined) {
-                throw dir;
-            }
+            assert(t === 'ok', result);
+            assertEq(result.length, 2, result);
+            assertNotNullish(result.find(x => x.name === 'file'));
+            assertNotNullish(result.find(x => x.name === 'dir'));
         },
         nested: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { cache: [vec8(0x15n)] } }
             })(readdir('tmp', { recursive: true }));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (result.length !== 1) {
-                throw result;
-            }
+            assert(t === 'ok', result);
+            assertEq(result.length, 1, result);
             const [r0] = result;
-            if (r0.name !== 'cache') {
-                throw r0;
-            }
-            if (r0.parentPath !== 'tmp') {
-                throw r0;
-            }
+            assertEq(r0.name, 'cache', r0);
+            assertEq(r0.parentPath, 'tmp', r0);
         },
         noSuchDir: () => {
             const [_, [t, result]] = virtual(emptyState)(readdir('tmp', { recursive: true }));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (result !== 'invalid path') {
-                throw result;
-            }
+            assert(t === 'error', result);
+            assertEq(result, 'invalid path');
         },
     },
     writeFile: {
         one: () => {
             const [state, [t, result]] = virtual(emptyState)(writeFile('hello', vec8(0x2an)));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const file = state.root.hello;
-            if (!Array.isArray(file)) {
-                throw file;
-            }
-            if (uint(file[0]) !== 0x2an) {
-                throw file;
-            }
+            assert(Array.isArray(file), file);
+            assertEq(uint(file[0]), 0x2an, file);
         },
         overwrite: () => {
             const [state, [t, result]] = virtual({
@@ -264,28 +189,16 @@ export const proof = {
                     hello: [vec8(0x15n)],
                 },
             })(writeFile('hello', vec8(0x2an)));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const file = state.root.hello;
-            if (!Array.isArray(file)) {
-                throw file;
-            }
-            if (uint(file[0]) !== 0x2an) {
-                throw file;
-            }
+            assert(Array.isArray(file), file);
+            assertEq(uint(file[0]), 0x2an, file);
         },
         nestedPath: () => {
             const [state, [t, result]] = virtual(emptyState)(writeFile('tmp/cache', vec8(0x2an)));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (result !== 'invalid file') {
-                throw result;
-            }
-            if (state.root.tmp !== undefined) {
-                throw state.root;
-            }
+            assert(t === 'error', result);
+            assertEq(result, 'invalid file');
+            assertEq(state.root.tmp, undefined, state.root);
         },
         directory: () => {
             const [state, [t, result]] = virtual({
@@ -294,30 +207,18 @@ export const proof = {
                     tmp: {},
                 },
             })(writeFile('tmp', vec8(0x2an)));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (result !== 'invalid file') {
-                throw result;
-            }
+            assert(t === 'error', result);
+            assertEq(result, 'invalid file');
             const tmp = state.root.tmp;
-            if (tmp === undefined || Array.isArray(tmp)) {
-                throw tmp;
-            }
+            assert(!(tmp === undefined || Array.isArray(tmp)), tmp);
         },
     },
     writeUtf8File: () => {
         const [state, [t, result]] = virtual(emptyState)(writeUtf8File('hello', 'Hello, world!'));
-        if (t !== 'ok') {
-            throw result;
-        }
+        assert(t === 'ok', result);
         const file = state.root.hello;
-        if (!Array.isArray(file)) {
-            throw file;
-        }
-        if (utf8ToString(file[0]) !== 'Hello, world!') {
-            throw file;
-        }
+        assert(Array.isArray(file), file);
+        assertEq(utf8ToString(file[0]), 'Hello, world!', file);
     },
     rm: {
         one: () => {
@@ -325,52 +226,32 @@ export const proof = {
                 ...emptyState,
                 root: { hello: [vec8(0x2an)] },
             })(rm('hello'));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (state.root.hello !== undefined) {
-                throw state.root;
-            }
+            assert(t === 'ok', result);
+            assertEq(state.root.hello, undefined, state.root);
         },
         nested: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { cache: [vec8(0x15n)] } },
             })(rm('tmp/cache'));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
-                throw state.root;
-            }
-            if (tmp.cache !== undefined) {
-                throw tmp;
-            }
+            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
+            assertEq(tmp.cache, undefined, tmp);
         },
         noSuchFile: () => {
             const [_, [t, result]] = virtual(emptyState)(rm('hello'));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (result !== 'no such file') {
-                throw result;
-            }
+            assert(t === 'error', result);
+            assertEq(result, 'no such file');
         },
         isDirectory: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: { tmp: {} },
             })(rm('tmp'));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (result !== 'invalid path') {
-                throw result;
-            }
-            if (state.root.tmp === undefined) {
-                throw state.root;
-            }
+            assert(t === 'error', result);
+            assertEq(result, 'invalid path');
+            assert(state.root.tmp !== undefined, state.root);
         },
     },
     both: () => {
@@ -381,24 +262,14 @@ export const proof = {
                 b: [vec8(0x15n)],
             },
         })(both(readFile('a'))(readFile('b')));
-        if (results[0][0] !== 'ok') {
-            throw results[0];
-        }
-        if (results[1][0] !== 'ok') {
-            throw results[1];
-        }
-        if (uint(results[0][1]) !== 0x2an) {
-            throw results[0][1];
-        }
-        if (uint(results[1][1]) !== 0x15n) {
-            throw results[1][1];
-        }
+        assert(results[0][0] === 'ok', results[0]);
+        assert(results[1][0] === 'ok', results[1]);
+        assertEq(uint(results[0][1]), 0x2an, results[0][1]);
+        assertEq(uint(results[1][1]), 0x15n, results[1][1]);
     },
     now: () => {
         const [_, result] = virtual({ ...emptyState, epochNs: 1_000_000 })(now());
-        if (result !== 1_000_000) {
-            throw result;
-        }
+        assertEq(result, 1_000_000);
     },
     sandbox: {
         // Virtual `sandbox` is now a pass-through: the function is expected
@@ -406,41 +277,27 @@ export const proof = {
         // (and `duration`) instead of the runner measuring.
         ok: () => {
             const [_, { result, duration }] = virtual(emptyState)(sandbox(() => ({ result: ['ok', 42], duration: 0 })));
-            if (result[0] !== 'ok') {
-                throw result;
-            }
-            if (result[1] !== 42) {
-                throw result[1];
-            }
-            if (duration !== 0) {
-                throw duration;
-            }
+            assert(result[0] === 'ok', result);
+            assertEq(result[1], 42);
+            assertEq(duration, 0);
         },
         error: () => {
             const err = new Error('fail');
             const [_, { result }] = virtual(emptyState)(sandbox(() => ({ result: ['error', err], duration: 0 })));
-            if (result[0] !== 'error') {
-                throw result;
-            }
-            if (result[1] !== err) {
-                throw result[1];
-            }
+            assert(result[0] === 'error', result);
+            assertEq(result[1], err);
         },
     },
     memory: {
         createAndRead: () => {
-            const effect = memCreate(42).step(key => memRead(key));
+            const effect = step(memCreate(42), key => memRead(key));
             const [_, value] = virtual(emptyState)(effect);
-            if (value !== 42) {
-                throw value;
-            }
+            assertEq(value, 42);
         },
         createAndWrite: () => {
-            const effect = memCreate(1).step(key => memWrite(key, 99).step(() => memRead(key)));
+            const effect = step(memCreate(1), key => step(memWrite(key, 99), () => memRead(key)));
             const [_, value] = virtual(emptyState)(effect);
-            if (value !== 99) {
-                throw value;
-            }
+            assertEq(value, 99);
         },
     },
     rename: {
@@ -449,52 +306,32 @@ export const proof = {
                 ...emptyState,
                 root: { src: [vec8(0x2an)], dst: [vec8(0x15n)] },
             })(rename('src', 'dst'));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (state.root.src !== undefined) {
-                throw state.root;
-            }
-            if (!Array.isArray(state.root.dst)) {
-                throw state.root;
-            }
-            if (uint(state.root.dst[0]) !== 0x2an) {
-                throw state.root;
-            }
+            assert(t === 'ok', result);
+            assertEq(state.root.src, undefined, state.root);
+            assert(Array.isArray(state.root.dst), state.root);
+            assertEq(uint(state.root.dst[0]), 0x2an, state.root);
         },
         nestedRename: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: { tmp: { src: [vec8(0x2an)] } },
             })(rename('tmp/src', 'tmp/dst'));
-            if (t !== 'ok') {
-                throw result;
-            }
+            assert(t === 'ok', result);
             const tmp = state.root.tmp;
-            if (typeof tmp !== 'object' || Array.isArray(tmp)) {
-                throw state.root;
-            }
-            if (tmp.src !== undefined) {
-                throw tmp;
-            }
+            assert(!(typeof tmp !== 'object' || Array.isArray(tmp)), state.root);
+            assertEq(tmp.src, undefined, tmp);
         },
         dirOverFile: () => {
             const [state, [t, result]] = virtual({
                 ...emptyState,
                 root: { src: {}, dst: [vec8(0x15n)] },
             })(rename('src', 'dst'));
-            if (t !== 'error') {
-                throw result;
-            }
-            if (!Array.isArray(state.root.dst)) {
-                throw state.root;
-            }
+            assert(t === 'error', result);
+            assert(Array.isArray(state.root.dst), state.root);
         },
         missingSource: () => {
             const [_, [t, result]] = virtual(emptyState)(rename('missing', 'dst'));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
         },
     },
     readBytes: {
@@ -503,55 +340,37 @@ export const proof = {
                 ...emptyState,
                 root: { file: [vec8(0xabn)] },
             })(readBytes('file', 0, 1));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (!isVec(result)) {
-                throw result;
-            }
+            assert(t === 'ok', result);
+            assert(isVec(result), result);
         },
         withOffset: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: { file: [vec8(0xabn), vec8(0xcdn)] },
             })(readBytes('file', 1, 1));
-            if (t !== 'ok') {
-                throw result;
-            }
-            if (!isVec(result)) {
-                throw result;
-            }
+            assert(t === 'ok', result);
+            assert(isVec(result), result);
         },
         oversizeChunk: () => {
             const [_, [t, result]] = virtual({
                 ...emptyState,
                 root: { file: [vec8(0x2an)] },
             })(readBytes('file', 0, Number(2n ** 32n)));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
         },
         missingFile: () => {
             const [_, [t, result]] = virtual(emptyState)(readBytes('missing', 0, 4));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
         },
     },
     randomInt: {
         increments: () => {
             const [state1, r1] = virtual(emptyState)(randomInt());
-            if (r1 !== 0) {
-                throw r1;
-            }
+            assertEq(r1, 0);
             const [state2, r2] = virtual(state1)(randomInt());
-            if (r2 !== 1) {
-                throw r2;
-            }
+            assertEq(r2, 1);
             const [_, r3] = virtual(state2)(randomInt());
-            if (r3 !== 2) {
-                throw r3;
-            }
+            assertEq(r3, 2);
         },
     },
     writeFromStream: {
@@ -562,13 +381,16 @@ export const proof = {
                 ...emptyState,
                 root: { hello: [vec8(0x2an)] },
             })(writeFromStream('hello', listEmpty()));
-            if (t !== 'error') {
-                throw result;
-            }
+            assert(t === 'error', result);
             const file = state.root.hello;
-            if (!Array.isArray(file) || uint(file[0]) !== 0x2an) {
-                throw file;
-            }
+            assert(!(!Array.isArray(file) || uint(file[0]) !== 0x2an), file);
+        },
+        invalidBufferSize: () => {
+            // A chunk whose bit length isn't a multiple of 8 trips the
+            // byte-alignment guard before `writeBytes` is ever called.
+            const [_, [t, result]] = virtual(emptyState)(writeFromStream('hello', listNonEmpty(['ok', vec(4n)(10n)], listEmpty())));
+            assert(t === 'error', result);
+            assertEq(result, 'invalid buffer size');
         },
     },
 };

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

@@ -6,6 +6,7 @@ export declare const proof: {
     };
     writeFileOnDirectory: () => void;
     readdirRecursive: () => void;
+    accessNestedPathThroughFile: () => void;
     readFileIntoDir: () => void;
     awaitNonPromise: () => void;
     fetchNotFound: () => void;