functionalscript 0.8.2 → 0.9.2

package/ci/module.f.js

@@ -1,3 +1,5 @@
+import { utf8 } from "../text/module.f.js";
+import { writeFile } from "../types/effect/node/module.f.js";
 const os = ['ubuntu', 'macos', 'windows'];
 const architecture = ['intel', 'arm'];
 // https://docs.github.com/en/actions/reference/runners/github-hosted-runners#standard-github-hosted-runners-for-public-repositories
@@ -73,7 +75,7 @@ const toSteps = (m) => {
         ...(rust ? [{
                 // wasm32-wasip1-threads doesn't work on Rust 1.91 in the release mode.
                 // See https://github.com/sergey-shandar/wasmtime-crash
-                uses: 'dtolnay/rust-toolchain@1.90.0',
+                uses: 'dtolnay/rust-toolchain@1.93.0',
                 with: {
                     components: 'rustfmt,clippy',
                     targets
@@ -128,8 +130,8 @@ const steps = (v) => (a) => {
             // publishing
             test({ run: 'npm pack' }),
             test({ run: `npm install -g ${findTgz(v)}` }),
-            test({ run: 'fsc issues/demo/data/tree.json _tree.f.js' }),
-            test({ run: 'fst' }),
+            test({ run: 'fjs compile issues/demo/data/tree.json _tree.f.js' }),
+            test({ run: 'fjs t' }),
             test({ run: 'npm uninstall functionalscript -g' }),
         ]),
         // Deno
@@ -137,14 +139,15 @@ const steps = (v) => (a) => {
             installDeno(v)(a),
             test({ run: 'deno install' }),
             test({ run: 'deno task test' }),
-            test({ run: 'deno task fst' }),
+            test({ run: 'deno task fjs compile issues/demo/data/tree.json _tree.f.js' }),
+            test({ run: 'deno task fjs t' }),
             test({ run: 'deno publish --dry-run' }),
         ]),
         // Bun
         ...clean([
             installBun(v)(a),
             test({ run: 'bun test --timeout 20000' }),
-            test({ run: 'bun ./dev/tf/module.ts' }),
+            test({ run: 'bun ./fjs/module.ts t' }),
         ]),
     ];
     return toSteps(result);
@@ -163,7 +166,6 @@ const gha = {
     on: { pull_request: {} },
     jobs,
 };
-export default async (io) => {
-    io.fs.writeFileSync('.github/workflows/ci.yml', JSON.stringify(gha, null, '  '));
-    return 0;
-};
+export const effect = writeFile('.github/workflows/ci.yml', utf8(JSON.stringify(gha, null, '  ')))
+    .map(() => 0);
+export default () => effect;

package/ci/module.js

@@ -1,3 +1,3 @@
-import node from "../io/module.js";
-import x from "./module.f.js";
-await node(x);
+import { nodeRun } from "../io/module.js";
+import run from "./module.f.js";
+await nodeRun(run);

package/crypto/sha2/module.f.js

@@ -1,6 +1,5 @@
 import { mask } from "../../types/bigint/module.f.js";
 import { vec, length, empty, msb } from "../../types/bit_vec/module.f.js";
-import { flip } from "../../types/function/module.f.js";
 import { fold } from "../../types/list/module.f.js";
 const { concat, popFront, front } = msb;
 const lastOne = vec(1n)(1n);

package/dev/module.f.d.ts

@@ -1,4 +1,4 @@
-import type { Io } from '../io/module.f.ts';
+import { type Io } from '../io/module.f.ts';
 export declare const todo: () => never;
 export type Module = {
     readonly default?: unknown;

package/dev/module.f.js

@@ -1,4 +1,9 @@
+import { fromIo } from "../io/module.f.js";
 import { updateVersion } from "./version/module.f.js";
+import { decodeUtf8, encodeUtf8 } from "../types/uint8array/module.f.js";
+import { readFile } from "../types/effect/node/module.f.js";
+import { utf8ToString } from "../text/module.f.js";
+import { unwrap } from "../types/result/module.f.js";
 export const todo = () => { throw 'not implemented'; };
 const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
 export const env = ({ process: { env } }) => a => {
@@ -8,7 +13,7 @@ export const env = ({ process: { env } }) => a => {
             r.value;
 };
 export const allFiles = (io) => (s) => {
-    const { fs: { promises: { readdir } }, process: { cwd } } = io;
+    const { fs: { promises: { readdir } } } = io;
     const load = async (p) => {
         let result = [];
         for (const i of await readdir(p, { withFileTypes: true })) {
@@ -46,18 +51,21 @@ export const loadModuleMap = async (io) => {
     }
     return Object.fromEntries(map.toSorted(cmp));
 };
+const denoJson = './deno.json';
+const index2 = updateVersion
+    .pipe(() => readFile(denoJson))
+    .map(v => JSON.parse(utf8ToString(unwrap(v))));
 export const index = async (io) => {
-    updateVersion(io);
-    const jj = './deno.json';
-    const jsr_json = JSON.parse(await io.fs.promises.readFile(jj, 'utf8'));
+    const runner = fromIo(io);
+    const jsr_json = await runner(index2);
     const list = (await allFiles(io)('.')).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
-    //console.log(list)
+    // console.log(list)
     const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
     // console.log(exportsA)
     const exports = Object.fromEntries(exportsA);
     // console.log(exports)
     const json = JSON.stringify({ ...jsr_json, exports }, null, 2);
     // console.log(json)
-    await io.fs.promises.writeFile(jj, json, 'utf8');
+    await io.fs.promises.writeFile(denoJson, encodeUtf8(json));
     return 0;
 };

package/dev/version/module.f.d.ts

@@ -1,11 +1,2 @@
-export type Buffer = object;
-type Fs<T> = {
-    readonly readFileSync: (name: string, encoding: 'utf8') => string;
-    readonly writeFileSync: (name: string, content: string) => T;
-};
-export type Node<T> = {
-    readonly fs: Fs<T>;
-};
-export declare const getVersion: <T>(fs: Fs<T>) => string;
-export declare const updateVersion: <T>(node: Node<T>) => readonly [T, T];
-export {};
+import { type NodeEffect } from "../../types/effect/node/module.f.ts";
+export declare const updateVersion: NodeEffect<number>;

package/dev/version/module.f.js

@@ -1,16 +1,19 @@
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { all } from "../../types/effect/module.f.js";
+import { readFile, writeFile } from "../../types/effect/node/module.f.js";
+import { unwrap } from "../../types/result/module.f.js";
 const { stringify, parse } = JSON;
-export const getVersion = fs => readJson(fs)('package').version;
 const jsonFile = (jsonFile) => `${jsonFile}.json`;
-const readJson = fs => name => parse(fs.readFileSync(jsonFile(name), 'utf8'));
-export const updateVersion = ({ fs }) => {
-    const f = (name) => {
-        return fs.writeFileSync(jsonFile(name), stringify({
-            ...readJson(fs)(name),
-            version: getVersion(fs)
-        }, null, 2));
-    };
-    return [
-        f('package'),
-        f('deno')
-    ];
-};
+const readJson = (name) => readFile(jsonFile(name))
+    .map(v => parse(utf8ToString(unwrap(v))));
+const writeVersion = (version) => (name) => readJson(name)
+    .pipe(json => writeFile(jsonFile(name), utf8(stringify({
+    ...json,
+    version,
+}, null, 2))));
+export const updateVersion = readJson('package')
+    .pipe(p => {
+    const w = writeVersion(p.version);
+    return all([w('package'), w('deno')]);
+})
+    .map(() => 0);

package/dev/version/test.f.d.ts

@@ -1,2 +1,4 @@
-declare const _default: () => void;
+declare const _default: {
+    new: () => void;
+};
 export default _default;

package/dev/version/test.f.js

@@ -1,4 +1,10 @@
-import * as _ from "./module.f.js";
+import { utf8, utf8ToString } from "../../text/module.f.js";
+import { isVec } from "../../types/bit_vec/module.f.js";
+import { run } from "../../types/effect/mock/module.f.js";
+import { all } from "../../types/effect/module.f.js";
+import { writeFile } from "../../types/effect/node/module.f.js";
+import { emptyState, virtual } from "../../types/effect/node/virtual/module.f.js";
+import { updateVersion } from "./module.f.js";
 const version = '0.3.0';
 const x = {
     'package.json': {
@@ -73,15 +79,25 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default () => {
-    const node = {
-        fs: {
-            readFileSync: n => JSON.stringify(x[n]),
-            writeFileSync: (_, content) => content
+export default {
+    new: () => {
+        const rv = run(virtual);
+        const w = (name) => {
+            const fn = `${name}.json`;
+            return writeFile(fn, utf8(JSON.stringify(x[fn])));
+        };
+        const [state] = rv(emptyState)(all([w('package'), w('deno')]));
+        const [newState, result] = rv(state)(updateVersion);
+        if (result !== 0) {
+            throw result;
+        }
+        const vec = newState.root['package.json'];
+        if (!isVec(vec)) {
+            throw vec;
+        }
+        const n = utf8ToString(vec);
+        if (n !== e) {
+            throw [n, e];
         }
-    };
-    const [n, d] = _.updateVersion(node);
-    if (n !== e) {
-        throw [n, e];
     }
 };

package/djs/module.f.d.ts

@@ -6,4 +6,4 @@ export type Object = {
 export type Array = readonly Unknown[];
 export type Primitive = JsonPrimitive | bigint | undefined;
 export type Unknown = Primitive | Object | Array;
-export declare const compile: ({ console: { error }, fs, process: { argv } }: Io) => Promise<number>;
+export declare const compile: ({ console: { error }, fs }: Io) => (args: readonly string[]) => Promise<number>;

package/djs/module.f.js

@@ -1,8 +1,8 @@
 import { transpile } from "./transpiler/module.f.js";
 import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-export const compile = ({ console: { error }, fs, process: { argv } }) => {
-    const args = argv.slice(2);
+import { encodeUtf8 } from "../types/uint8array/module.f.js";
+export const compile = ({ console: { error }, fs }) => (args) => {
     if (args.length < 2) {
         error('Error: Requires 2 or more arguments');
         return Promise.resolve(1);
@@ -14,11 +14,11 @@ export const compile = ({ console: { error }, fs, process: { argv } }) => {
         case 'ok': {
             if (outputFileName.endsWith('.json')) {
                 const output = stringifyAsTree(sort)(result[1]);
-                fs.writeFileSync(outputFileName, output);
+                fs.writeFileSync(outputFileName, encodeUtf8(output));
                 break;
             }
             const output = stringify(sort)(result[1]);
-            fs.writeFileSync(outputFileName, output);
+            fs.writeFileSync(outputFileName, encodeUtf8(output));
             break;
         }
         case 'error': {

package/djs/parser-new/module.f.d.ts

@@ -0,0 +1,3 @@
+import { type Rule } from "../../bnf/module.f.ts";
+export declare const parse: (input: string) => boolean;
+export declare const jsGrammar: () => Rule;

package/djs/parser-new/module.f.js

@@ -0,0 +1,150 @@
+import { descentParser } from "../../bnf/data/module.f.js";
+import { eof, join0Plus, max, none, not, notSet, oneEncode, option, range, remove, repeat, repeat0Plus, repeat1Plus, set, unicodeRange } from "../../bnf/module.f.js";
+import { todo } from "../../dev/module.f.js";
+export const parse = (input) => {
+    const m = descentParser(jsGrammar());
+    return todo();
+};
+export const jsGrammar = () => {
+    const onenine = range('19');
+    const digit = range('09');
+    const string = [
+        '"',
+        repeat0Plus({
+            ...remove(range(` ${max}`), set('"\\')),
+            escape: [
+                '\\',
+                {
+                    ...set('"\\/bfnrt'),
+                    u: [
+                        'u',
+                        ...repeat(4)({
+                            digit,
+                            AF: range('AF'),
+                            af: range('af'),
+                        })
+                    ],
+                }
+            ],
+        }),
+        '"'
+    ];
+    const digits0 = repeat0Plus(digit);
+    const digits = [digit, digits0];
+    const number = [
+        {
+            0: '0',
+            onenine: [onenine, digits0],
+        },
+        option({
+            bigint: 'n',
+            frac: [
+                option(['.', digits]),
+                option([set('Ee'), option(set('+-')), digits])
+            ]
+        })
+    ];
+    const ws = set(' \t');
+    const newLine = set('\n\r');
+    const idStart = {
+        smallLetter: range('az'),
+        bigLetter: range('AZ'),
+        lowLine: '_',
+        dollarSign: '$'
+    };
+    const idChar = {
+        ...idStart,
+        digit
+    };
+    const id = [idStart, repeat0Plus(idChar)];
+    const operator = {
+        '.': '.',
+        '=>': '=>',
+        '===': '===',
+        '==': '==',
+        '=': '=',
+        '!==': '!==',
+        '!=': '!=',
+        '!': '!',
+        '>>>=': '>>>=',
+        '>>>': '>>>',
+        '>>=': '>>=',
+        '>>': '>>',
+        '>=': '>=',
+        '>': '>',
+        '<<<<=': '<<<=',
+        '<<<': '<<<',
+        '<<=': '<<=',
+        '<<': '<<',
+        '<=': '<=',
+        '<': '<',
+        '+=': '+=',
+        '++': '++',
+        '+': '+',
+        '-=': '-=',
+        '--': '--',
+        '-': '-',
+        '**=': '**=',
+        '**': '**',
+        '*=': '*=',
+        '*': '*',
+        '/=': '/=',
+        '/': '/',
+        '%=': '%=',
+        '%': '%',
+        '&&=': '&&=',
+        '&&': '&&',
+        '&=': '&=',
+        '&': '&',
+        '||=': '||=',
+        '||': '||',
+        '|=': '|=',
+        '|': '|',
+        '^=': '^=',
+        '^': '^',
+        '~': '~',
+        '??=': '??=',
+        '??': '??',
+        '?.': '?.',
+        '?': '?',
+        '[': '[',
+        ']': ']',
+        '{': '{',
+        '}': '}',
+        '(': '(',
+        ')': ')',
+        ',': ',',
+        ':': ':'
+    };
+    const commentEnd = {
+        ...newLine,
+        eof
+    };
+    const comment = ['/', {
+            // TODO: investigate why `not(commentEnd)` instead of `remove(unicodeRange, newLine)` fail tests.
+            // TODO: should it be `repeat0Plus(not(commentEnd))` instead of `option(remove(unicodeRange, newLine))`.
+            oneline: ['/', option(remove(unicodeRange, newLine)), commentEnd],
+            multiline: [
+                '*',
+                repeat0Plus({
+                    na: notSet('*'),
+                    a: ['*', notSet('/')]
+                }),
+                '*/'
+            ]
+        }
+    ];
+    const endOfFile = oneEncode(eof);
+    const token = {
+        number,
+        string,
+        id,
+        comment,
+        operator,
+        ws,
+        newLine,
+        //endOfFile
+    };
+    const tokens = repeat0Plus(token);
+    return tokens;
+};

package/djs/parser-new/test.f.d.ts

@@ -0,0 +1,5 @@
+declare const _default: {
+    isValid: (() => void)[];
+    parser: (() => void)[];
+};
+export default _default;

package/djs/parser-new/test.f.js

@@ -0,0 +1,201 @@
+import { descentParser } from "../../bnf/data/module.f.js";
+import { stringToCodePointList } from "../../text/utf16/module.f.js";
+import { map, toArray } from "../../types/list/module.f.js";
+import { jsGrammar } from "./module.f.js";
+const mapCodePoint = (cp) => [cp, undefined];
+const descentParserCpOnly = (m, name, cp) => {
+    const cpm = toArray(map(mapCodePoint)(cp));
+    return m(name, cpm);
+};
+export default {
+    isValid: [() => {
+            const m = descentParser(jsGrammar());
+            const expect = (s, expected) => {
+                const cp = toArray(stringToCodePointList(s));
+                const mr = descentParserCpOnly(m, '', cp);
+                const success = mr[1] && mr[2] === cp.length;
+                if (success !== expected) {
+                    throw mr;
+                }
+            };
+            expect('   true   ', true);
+            expect('   tr2ue   ', true);
+            expect('   2true   ', true);
+            expect('   true"   ', false);
+            expect('   "Hello"   ', true);
+            expect('   "Hello   ', false);
+            expect('   "Hello\\n\\r\\""   ', true);
+            expect('   56.7e+5  ', true);
+            expect('   -56.7e+5  ', true);
+            expect('   h-56.7e+5   ', true);
+            expect('   -56.7e+5   3', true);
+            expect('   [] ', true);
+            expect('   {} ', true);
+            expect('   [[[]]] ', true);
+            expect('   [1] ', true);
+            expect('   [ 12, false, "a"]  ', true);
+            expect('   [ 12, false2, "a"]  ', true);
+            expect('   { "q": [ 12, false, [{"b" : "c"}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [{}], "a"] }  ', true);
+            expect('   { "q": [ 12, false, [}], "a"] }  ', true);
+            expect('   [{ "q": [ 12, false, [{}], "a"] }]  ', true);
+            expect('   [{ "q": [ 12, false, [}], "a"] }]  ', true);
+            expect('. + ++ +=', true);
+            expect('//12\n', true);
+            expect('/*12*/', true);
+            expect('/* 1*2 */', true);
+        }
+    ],
+    parser: [
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('tr'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'id')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('"tr"'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'string')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56.7e+5'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('56n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'number')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('*'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '*')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('**'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '**')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=>'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=>')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('=='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '==')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('==='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '===')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('='));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '=')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList(' '));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== ' ')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '\n')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== '/')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('//\n'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        },
+        () => {
+            const m = descentParser(jsGrammar());
+            const cp = toArray(stringToCodePointList('/*1*/'));
+            const mr = descentParserCpOnly(m, '', cp);
+            const seq = mr[0].sequence[0];
+            if (seq instanceof Array)
+                throw JSON.stringify(mr);
+            if (seq.tag !== 'comment')
+                throw JSON.stringify(mr);
+        }
+    ]
+};

package/djs/serializer/module.f.js

@@ -53,9 +53,9 @@ export const serializeWithoutConst = sort => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         switch (typeof value) {
@@ -96,9 +96,9 @@ const serializeWithConst = sort => refs => root => {
     ]);
     const mapPropertySerialize = map(propertySerialize);
     const objectSerialize = fn(entries)
-        .then(sort)
-        .then(mapPropertySerialize)
-        .then(objectWrap)
+        .map(sort)
+        .map(mapPropertySerialize)
+        .map(objectWrap)
         .result;
     const f = value => {
         if (value !== root) {