functionalscript 0.37.0 → 0.38.0

package/{fs → fjs}/djs/transpiler/proof.f.d.ts

@@ -2,6 +2,9 @@ export declare const proof: {
     parse: () => void;
     parseWithSubModule: () => void;
     parseWithSubModules: () => void;
+    parseWithIdentifierKeys: () => void;
+    parseWithConstIdentifier: () => void;
+    parseWithUnaryMinusOperator: () => void;
     parseWithFileNotFoundError: () => void;
     parseWithCycleError: () => void;
 };

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

@@ -3,6 +3,7 @@ import { transpile } from './module.f.js';
 import { stringifyAsTree } from '../serializer/module.f.js';
 import { virtual, emptyState } from '../../effects/node/virtual/module.f.js';
 import { utf8 } from '../../text/module.f.js';
+import { assert, assertEq } from '../../asserts/module.f.js';
 const run = (root) => (path) => {
     const [_, result] = virtual({ ...emptyState, root })(transpile(path));
     return result;
@@ -10,23 +11,15 @@ const run = (root) => (path) => {
 export const proof = {
     parse: () => {
         const result = run({ a: [utf8('export default 1')] })('a');
-        if (result[0] === 'error') {
-            throw result[1];
-        }
+        assert(result[0] !== 'error', result[1]);
         const s = stringifyAsTree(sort)(result[1]);
-        if (s !== '1') {
-            throw s;
-        }
+        assertEq(s, '1');
     },
     parseWithSubModule: () => {
         const result = run({ a: { b: [utf8('import c from "c"\nexport default c')], c: [utf8('export default 2')] } })('a/b');
-        if (result[0] === 'error') {
-            throw result[1];
-        }
+        assert(result[0] !== 'error', result[1]);
         const s = stringifyAsTree(sort)(result[1]);
-        if (s !== '2') {
-            throw s;
-        }
+        assertEq(s, '2');
     },
     parseWithSubModules: () => {
         const result = run({
@@ -35,22 +28,32 @@ export const proof = {
             c: [utf8('import d from "d"\nexport default [1,d]')],
             d: [utf8('export default 2')],
         })('a');
-        if (result[0] === 'error') {
-            throw result[1];
-        }
+        assert(result[0] !== 'error', result[1]);
         const s = stringifyAsTree(sort)(result[1]);
-        if (s !== '[[0,2],[1,2],[0,2]]') {
-            throw s;
-        }
+        assertEq(s, '[[0,2],[1,2],[0,2]]');
+    },
+    parseWithIdentifierKeys: () => {
+        const result = run({ a: [utf8('export default {a:1,b:2}')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '{"a":1,"b":2}');
+    },
+    parseWithConstIdentifier: () => {
+        const result = run({ a: [utf8('const a = 1\nconst b = a\nexport default {x:a,y:b}')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '{"x":1,"y":1}');
+    },
+    parseWithUnaryMinusOperator: () => {
+        const result = run({ a: [utf8('export default [-1,2,-3]')] })('a');
+        assert(result[0] !== 'error', result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
+        assertEq(s, '[-1,2,-3]');
     },
     parseWithFileNotFoundError: () => {
         const result = run({ a: [utf8('import b from "b"\nexport default b')] })('a');
-        if (result[0] !== 'error') {
-            throw result;
-        }
-        if (result[1].message !== 'file not found') {
-            throw result;
-        }
+        assert(result[0] === 'error', result);
+        assertEq(result[1].message, 'file not found', result);
     },
     parseWithCycleError: () => {
         const result = run({
@@ -58,11 +61,7 @@ export const proof = {
             b: [utf8('import c from "c"\nexport default c')],
             c: [utf8('import b from "b"\nexport default b')],
         })('a');
-        if (result[0] !== 'error') {
-            throw result;
-        }
-        if (result[1].message !== 'circular dependency') {
-            throw result;
-        }
+        assert(result[0] === 'error', result);
+        assertEq(result[1].message, 'circular dependency', result);
     },
 };

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

@@ -1,3 +1,4 @@
+import { assert, assertEq } from '../../asserts/module.f.js';
 import { run } from '../mock/module.f.js';
 import { pure } from '../module.f.js';
 import { asBase, asNominal, create, read, write, } from './module.f.js';
@@ -14,9 +15,7 @@ const mock = {
     memRead: key => state => [state, state.values[asBase(key)]],
     memWrite: (key, value) => state => {
         const id = asBase(key);
-        if (!(id in state.values)) {
-            throw id;
-        }
+        assert(id in state.values, id);
         return [{
                 ...state,
                 values: { ...state.values, [id]: value },
@@ -27,12 +26,8 @@ const program = create(1).step(key => read(key).step(value => write(key, value +
 export const proof = {
     roundTrip: () => {
         const [state, result] = run(mock)(initial)(program);
-        if (result !== 42) {
-            throw result;
-        }
-        if (state.values.k0 !== 42) {
-            throw state;
-        }
+        assertEq(result, 42);
+        assertEq(state.values.k0, 42, state);
     },
     allocatesFreshKeys: () => {
         const effect = create('a').step(a => create('b').step(b => pure([
@@ -40,18 +35,10 @@ export const proof = {
             asBase(b),
         ])));
         const [state, [a, b]] = run(mock)(initial)(effect);
-        if (a !== 'k0') {
-            throw a;
-        }
-        if (b !== 'k1') {
-            throw b;
-        }
-        if (state.values.k0 !== 'a') {
-            throw state;
-        }
-        if (state.values.k1 !== 'b') {
-            throw state;
-        }
+        assertEq(a, 'k0');
+        assertEq(b, 'k1');
+        assertEq(state.values.k0, 'a', state);
+        assertEq(state.values.k1, 'b', state);
     },
     typeTest: () => {
         // const e = create(1).step(k => write(k, 'bad').step(() => read(k)))

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

@@ -6,30 +6,23 @@
 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';
 export const proof = {
     nodeInterpreter: async () => {
         const result = await run(create(1).step(key => write(key, 2).step(() => read(key))));
-        if (result !== 2) {
-            throw result;
-        }
+        assertEq(result, 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>;

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;
     };
 };