functionalscript 0.37.0 → 0.39.0

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

@@ -1,4 +1,5 @@
 import { sloth, p } from './module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const { eval: evalVdf, verify, modSqrt, quadRes } = sloth;
 // `eval(steps)(x)` expected values for {@link p}; same Sloth algorithm as
 // https://github.com/hyperhyperspace/pulsar/blob/main/src/model/SlothVDF.ts and
@@ -14,122 +15,80 @@ const y4 = 644011502652234436942449645950841972378141575340402198193426476647825
 export const proof = {
     p: {
         matchesField: () => {
-            if (sloth.p !== p) {
-                throw [sloth.p, p];
-            }
+            assertEq(sloth.p, p, [sloth.p, p]);
         },
     },
     eval: {
         steps100: () => {
             const y = evalVdf(100n)(sampleX);
-            if (y !== sampleY) {
-                throw [y, sampleY];
-            }
+            assertEq(y, sampleY, [y, sampleY]);
         },
         steps10: () => {
             const y = evalVdf(10n)(smallX);
-            if (y !== smallY) {
-                throw [y, smallY];
-            }
+            assertEq(y, smallY, [y, smallY]);
         },
         steps6: () => {
             const y = evalVdf(6n)(largeX);
-            if (y !== y6) {
-                throw [y, y6];
-            }
+            assertEq(y, y6, [y, y6]);
         },
         steps4: () => {
             const y = evalVdf(4n)(smallX);
-            if (y !== y4) {
-                throw [y, y4];
-            }
+            assertEq(y, y4, [y, y4]);
         },
         zeroSteps: () => {
             const y = evalVdf(0n)(sampleX);
-            if (y !== sampleX % p) {
-                throw [y, sampleX % p];
-            }
+            assertEq(y, sampleX % p, [y, sampleX % p]);
         },
         negativeSteps: () => {
             const y = evalVdf(-1n)(sampleX);
-            if (y !== null) {
-                throw y;
-            }
+            assertEq(y, null);
         },
     },
     verify: {
         steps100: () => {
-            if (!verify(100n)(sampleX)(sampleY)) {
-                throw false;
-            }
+            assert(verify(100n)(sampleX)(sampleY), false);
         },
         steps10: () => {
-            if (!verify(10n)(smallX)(smallY)) {
-                throw false;
-            }
+            assert(verify(10n)(smallX)(smallY), false);
         },
         steps6: () => {
-            if (!verify(6n)(largeX)(y6)) {
-                throw false;
-            }
+            assert(verify(6n)(largeX)(y6), false);
         },
         steps4: () => {
-            if (!verify(4n)(smallX)(y4)) {
-                throw false;
-            }
+            assert(verify(4n)(smallX)(y4), false);
         },
         tampered: () => {
-            if (verify(4n)(smallX)((y4 + 1n) % p)) {
-                throw (y4 + 1n) % p;
-            }
+            assert(!(verify(4n)(smallX)((y4 + 1n) % p)), (y4 + 1n) % p);
         },
         wrongY: () => {
-            if (verify(100n)(sampleX)(sampleY + 1n)) {
-                throw sampleY + 1n;
-            }
+            assert(!(verify(100n)(sampleX)(sampleY + 1n)), sampleY + 1n);
         },
         zeroSteps: () => {
-            if (!verify(0n)(sampleX)(sampleX % p)) {
-                throw [sampleX % p];
-            }
+            assert(verify(0n)(sampleX)(sampleX % p), [sampleX % p]);
         },
         negativeSteps: () => {
-            if (verify(-1n)(sampleX)(sampleY)) {
-                throw sampleY;
-            }
+            assert(!(verify(-1n)(sampleX)(sampleY)), sampleY);
         },
         invalidY: () => {
-            if (verify(100n)(sampleX)(0n)) {
-                throw 0n;
-            }
+            assert(!(verify(100n)(sampleX)(0n)), 0n);
         },
     },
     modSqrt: {
         roundTrip: () => {
             const x = 999n;
-            if (!verify(1n)(x)(modSqrt(x))) {
-                throw modSqrt(x);
-            }
+            assert(verify(1n)(x)(modSqrt(x)), modSqrt(x));
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
-            if (!verify(1n)(nonResidue)(modSqrt(nonResidue))) {
-                throw modSqrt(nonResidue);
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
+            assert(verify(1n)(nonResidue)(modSqrt(nonResidue)), modSqrt(nonResidue));
         },
     },
     quadRes: {
         one: () => {
-            if (!quadRes(1n)) {
-                throw 1n;
-            }
+            assert(quadRes(1n), 1n);
         },
         nonResidue: () => {
-            if (quadRes(nonResidue)) {
-                throw nonResidue;
-            }
+            assert(!(quadRes(nonResidue)), nonResidue);
         },
     },
 };

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

@@ -6,7 +6,7 @@
 import { all, import_, readdir } from '../effects/node/module.f.js';
 import { cmp as strCmp } from '../types/string/module.f.js';
 import { unwrap } from '../types/result/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 import { join, relativize, toPosix } from '../path/module.f.js';
 import { assert } from '../asserts/module.f.js';
 /**
@@ -25,32 +25,33 @@ export const shouldLoad = (s) => s.endsWith('.f.ts') || s.endsWith('.f.js') ||
     s.endsWith('proof.mts') || s.endsWith('proof.mjs');
 const isSourceFile = (path) => path.endsWith('.js') || path.endsWith('.ts') || path.endsWith('.mts') || path.endsWith('.mjs');
 const allFiles = (s, predicate) => {
-    const load = (p) => readdir(p, {})
-        .step(d => {
-        let result = [];
-        for (const i of unwrap(d)) {
-            const { name } = i;
-            if (name.startsWith('.')) {
-                continue;
-            }
-            const file = join(p, name);
-            if (!i.isFile) {
-                if (name === 'node_modules') {
+    const load = (p) => {
+        const x0 = step(readdir(p, {}), d => {
+            let result = [];
+            for (const i of unwrap(d)) {
+                const { name } = i;
+                if (name.startsWith('.')) {
                     continue;
                 }
-                result = [...result, load(file)];
-                continue;
-            }
-            if (predicate(file)) {
-                result = [...result, pure([file])];
+                const file = join(p, name);
+                if (!i.isFile) {
+                    if (name === 'node_modules') {
+                        continue;
+                    }
+                    result = [...result, load(file)];
+                    continue;
+                }
+                if (predicate(file)) {
+                    result = [...result, pure([file])];
+                }
             }
-        }
-        return all(...result);
-    })
-        .step(v => pure(v.flat()));
+            return all(...result);
+        });
+        return step(x0, v => pure(v.flat()));
+    };
     return load(s);
 };
-const loadFile = (f) => import_(f).step(r => pure([[f, unwrap(r)]]));
+const loadFile = (f) => step(import_(f), r => pure([[f, unwrap(r)]]));
 const { fromEntries } = Object;
 /**
  * Discovers all source files under `INIT_CWD` (or `.` if unset) that match
@@ -74,9 +75,8 @@ export const loadModuleMap = (env) => {
     //       we should consider optimize them by ALIQ technique or something similar.
     //       For example, we should be able to write it like `allFiles(s).flatMap(loadFile)`,
     //       then an effect runner can batch all file loading operations together.
-    return allFiles(s, shouldLoad)
-        .step(files => all(...files.map(loadFile)))
-        .step(entries => pure(fromEntries(entries
+    const x0 = step(allFiles(s, shouldLoad), files => all(...files.map(loadFile)));
+    return step(x0, entries => pure(fromEntries(entries
         .flat()
         .map(([k, v]) => [relativize(prefix, k), v])
         .toSorted(([a], [b]) => strCmp(a)(b)))));

package/{fs → fjs}/dev/package_json/proof.f.js

@@ -1,12 +1,12 @@
-import { assert } from '../../asserts/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 import { unwrap } from '../../types/result/module.f.js';
 import { validatePackageJson, validatePackageJsonText, } from './module.f.js';
 export const proof = {
     parseMetadata: () => {
         const result = unwrap(validatePackageJsonText('{"name":"x","version":"1.0.0","scripts":{"test":"node test.js"}}'));
-        assert(result.name === 'x', result);
-        assert(result.version === '1.0.0', result);
-        assert(result.scripts?.test === 'node test.js', result);
+        assertEq(result.name, 'x', result);
+        assertEq(result.version, '1.0.0', result);
+        assertEq(result.scripts?.test, 'node test.js', result);
     },
     malformedJson: () => {
         const result = validatePackageJsonText('{');
@@ -20,9 +20,9 @@ export const proof = {
     validatePreservesOriginalObject: () => {
         const object = { name: 'x', version: '1.0.0', private: true };
         const metadata = unwrap(validatePackageJson(object));
-        assert(metadata.name === 'x', metadata);
-        assert(metadata.version === '1.0.0', metadata);
+        assertEq(metadata.name, 'x', metadata);
+        assertEq(metadata.version, '1.0.0', metadata);
         assert(Object.is(metadata, object), metadata);
-        assert(object.private === true, object);
+        assertEq(object.private, true, object);
     },
 };

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

@@ -1,4 +1,4 @@
-import { assert, todo } from '../asserts/module.f.js';
+import { assert, assertEq, todo } from '../asserts/module.f.js';
 import { shouldLoad } from './module.f.js';
 export const proof = {
     shouldLoad: () => {
@@ -18,9 +18,7 @@ export const proof = {
         const c = (() => { })['constructor'];
         const f = c('return 5');
         const result = f();
-        if (result !== 5) {
-            throw 'function';
-        }
+        assertEq(result, 5, 'function');
     },
     ctorEmpty: () => {
         /** @type {any} */

package/{fs → fjs}/djs/ast/proof.f.js

@@ -6,30 +6,22 @@ export const proof = {
     test: () => {
         const djs = run([1])([]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '1') {
-            throw result;
-        }
+        assertEq(result, '1');
     },
     testCref: () => {
         const djs = run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '4') {
-            throw result;
-        }
+        assertEq(result, '4');
     },
     testAref: () => {
         const djs = run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '14') {
-            throw result;
-        }
+        assertEq(result, '14');
     },
     testArray: () => {
         const djs = run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
         const result = stringifyAsTree(sort)(djs);
-        if (result !== '[14,4]') {
-            throw result;
-        }
+        assertEq(result, '[14,4]');
     },
     testObj: () => {
         const djs = run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);

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

@@ -1,25 +1,22 @@
 import { transpile } from './transpiler/module.f.js';
 import { stringify, stringifyAsTree } from './serializer/module.f.js';
 import { sort } from '../types/object/module.f.js';
-import { pure } from '../effects/module.f.js';
+import { pure, step } from '../effects/module.f.js';
 import { writeUtf8File, error, } from '../effects/node/module.f.js';
 export const compile = args => {
     if (args.length < 2) {
-        return error('Error: Requires 2 or more arguments')
-            .step(() => pure(1));
+        return step(error('Error: Requires 2 or more arguments'), () => pure(1));
     }
     const inputFileName = args[0];
     const outputFileName = args[1];
-    return transpile(inputFileName).step((result) => {
+    return step(transpile(inputFileName), (result) => {
         if (result[0] === 'error') {
             const metadata = result[1].metadata;
-            return error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`)
-                .step(() => pure(0));
+            return step(error(`${metadata?.path}:${metadata?.line}:${metadata?.column} - error: ${result[1].message}`), () => pure(0));
         }
         const content = outputFileName.endsWith('.json')
             ? stringifyAsTree(sort)(result[1])
             : stringify(sort)(result[1]);
-        return writeUtf8File(outputFileName, content)
-            .step(() => pure(0));
+        return step(writeUtf8File(outputFileName, content), () => pure(0));
     });
 };

package/{fs → fjs}/djs/parser/module.f.d.ts

@@ -13,3 +13,11 @@ export type ParseError = {
     readonly metadata: TokenMetadata | null;
 };
 export declare const parseFromTokens: (tokenList: List<DjsTokenWithMetadata>) => Result<AstModule, ParseError>;
+export declare const proof: {
+    pushKey: {
+        nonObjectTop: () => void;
+    };
+    endArray: {
+        nonArrayTop: () => void;
+    };
+};

package/{fs → fjs}/djs/parser/module.f.js

@@ -7,6 +7,7 @@ import { error, ok } from '../../types/result/module.f.js';
 import { fold, first, drop, toArray, length, concat } from '../../types/list/module.f.js';
 import { setReplace, at } from '../../types/ordered_map/module.f.js';
 import { fromMap } from '../../types/object/module.f.js';
+import { assertEq } from '../../asserts/module.f.js';
 const parseInitialOp = ({ token, metadata }) => state => {
     switch (token.kind) {
         case 'ws':
@@ -361,3 +362,39 @@ export const parseFromTokens = (tokenList) => {
         default: return error({ message: 'unexpected end', metadata: null });
     }
 };
+export const proof = {
+    pushKey: {
+        // `pushKey` is only ever invoked while `state.top` is an object (the
+        // `'{'`/`'{,'` value-states guarantee it), so its non-object guard is
+        // a defensive branch unreachable through `parseFromTokens`. Call it
+        // directly to cover that branch.
+        nonObjectTop: () => {
+            const state = {
+                state: 'exportValue',
+                module: { refs: null, modules: null, consts: null },
+                valueState: '[',
+                top: null,
+                stack: null,
+            };
+            const result = pushKey(state)('key')({ path: 'test', line: 0, column: 0 });
+            assertEq(result.state, 'error');
+        },
+    },
+    endArray: {
+        // `endArray` is only ever invoked while `state.top` is an array (the
+        // `'['`/`'[v'`/`'[,'` value-states guarantee it), so its non-array
+        // guard is a defensive branch unreachable through `parseFromTokens`.
+        // Call it directly to cover that branch.
+        nonArrayTop: () => {
+            const state = {
+                state: 'exportValue',
+                module: { refs: null, modules: null, consts: null },
+                valueState: '[,',
+                top: null,
+                stack: null,
+            };
+            const result = endArray(state);
+            assertEq(result.state, 'result');
+        },
+    },
+};