functionalscript 0.9.1 → 0.9.2

package/README.md

@@ -26,7 +26,7 @@ This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and dist
 Install FunctionalScript via npm:
 
 ```bash
-npm install functionalscript
+npm install -g functionalscript
 ```
 
 The FunctionalScript compiler command (`fjs compile`) currently supports:
@@ -39,9 +39,9 @@ It does **not** yet support functions or complex expressions.
 Example usage with `fjs`:
 
 ```bash
-npx fjs compile example.f.js output.json
+fjs compile example.f.js output.json
 # or
-npx fjs compile example.f.js output.f.js
+fjs compile example.f.js output.f.js
 ```
 
 FunctionalScript code can be compiled directly into either JSON or JavaScript without imports.

package/bnf/module.f.d.ts

@@ -7,6 +7,9 @@ import { type Array2 } from '../types/array/module.f.ts';
  * - 0xEEEEEE is the last symbol (24 bits)
  */
 export type TerminalRange = number;
+export declare const fullRange: TerminalRange;
+export declare const unicodeRange: TerminalRange;
+export declare const eof = 1114112;
 /** A sequence of rules. */
 export type Sequence = readonly Rule[];
 /** A variant */
@@ -30,8 +33,9 @@ export declare const range: (ab: string) => TerminalRange;
 export type RangeVariant = {
     readonly [k in string]: TerminalRange;
 };
-export declare const rangeToId: (r: TerminalRange) => string;
-export declare const remove: (range: TerminalRange, removeSet: RangeVariant) => RangeVariant;
+export declare const remove: (range: TerminalRange, v: RangeVariant) => RangeVariant;
+export declare const not: (v: RangeVariant) => RangeVariant;
+export declare const notSet: (s: string) => RangeVariant;
 export type None = readonly [];
 export declare const none: None;
 export type Option<S> = {

package/bnf/module.f.js

@@ -1,6 +1,9 @@
 import { codePointListToString, stringToCodePointList } from "../text/utf16/module.f.js";
 import { isArray2 } from "../types/array/module.f.js";
 import { map, toArray, repeat as listRepeat } from "../types/list/module.f.js";
+export const fullRange = 0x000000_FFFFFF;
+export const unicodeRange = 0x000000_10FFFF;
+export const eof = 0x110000;
 // Internals:
 const { fromEntries, values } = Object;
 const { fromCodePoint } = String;
@@ -34,13 +37,7 @@ export const range = (ab) => {
     }
     return rangeEncode(...a);
 };
-export const rangeToId = (r) => {
-    const ab = rangeDecode(r);
-    const [a, b] = ab;
-    const cp = a === b ? [a] : ab;
-    return fromCodePoint(...cp);
-};
-const rangeToEntry = (r) => [rangeToId(r), r];
+const rangeToEntry = (r) => ['0x' + r.toString(16), r];
 const toVariantRangeSet = (r) => fromEntries(r.map(rangeToEntry));
 const removeOne = (list, ab) => {
     const [a, b] = rangeDecode(ab);
@@ -60,13 +57,15 @@ const removeOne = (list, ab) => {
     }
     return result;
 };
-export const remove = (range, removeSet) => {
+export const remove = (range, v) => {
     let result = [range];
-    for (const r of values(removeSet)) {
+    for (const r of values(v)) {
         result = removeOne(result, r);
     }
     return toVariantRangeSet(result);
 };
+export const not = (v) => remove(fullRange, v);
+export const notSet = (s) => not(set(s));
 export const none = [];
 export const option = (some) => ({
     some,

package/cas/module.f.d.ts

@@ -1,17 +1,18 @@
 import { type Sha2 } from "../crypto/sha2/module.f.ts";
-import type { Io } from "../io/module.f.ts";
-import { type Vec } from "../types/bit_vec/module.f.ts";
-export type KvStore = {
-    readonly read: (key: Vec) => Promise<Vec | undefined>;
-    readonly write: (key: Vec, value: Vec) => Promise<KvStore>;
-    readonly list: () => Promise<Iterable<Vec>>;
+import type { Vec } from "../types/bit_vec/module.f.ts";
+import { type Effect, type Operations } from "../types/effect/module.f.ts";
+import { type Fs, type NodeOperations } from "../types/effect/node/module.f.ts";
+export type KvStore<O extends Operations> = {
+    readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    readonly write: (key: Vec, value: Vec) => Effect<O, void>;
+    readonly list: () => Effect<O, readonly Vec[]>;
 };
 export type Kv = readonly [Vec, Vec];
-export declare const memKvStore: () => KvStore;
-export declare const fileKvStore: (io: Io) => (path: string) => KvStore;
-export type Cas = {
-    readonly read: (key: Vec) => Promise<Vec | undefined>;
-    readonly write: (value: Vec) => Promise<readonly [Cas, Vec]>;
-    readonly list: () => Promise<Iterable<Vec>>;
+export declare const fileKvStore: (path: string) => KvStore<Fs>;
+export type Cas<O extends Operations> = {
+    readonly read: (key: Vec) => Effect<O, Vec | undefined>;
+    readonly write: (value: Vec) => Effect<O, Vec>;
+    readonly list: () => Effect<O, readonly Vec[]>;
 };
-export declare const cas: (sha2: Sha2) => (s: KvStore) => Cas;
+export declare const cas: (sha2: Sha2) => <O extends Operations>(_: KvStore<O>) => Cas<O>;
+export declare const main: (args: readonly string[]) => Effect<NodeOperations, number>;

package/cas/module.f.js

@@ -1,77 +1,95 @@
-import { computeSync } from "../crypto/sha2/module.f.js";
-import { todo } from "../dev/module.f.js";
-import {} from "../types/bit_vec/module.f.js";
+import { computeSync, sha256 } from "../crypto/sha2/module.f.js";
+import { parse } from "../path/module.f.js";
 import { cBase32ToVec, vecToCBase32 } from "../types/cbase32/module.f.js";
-import { compose } from "../types/function/module.f.js";
+import { pure } from "../types/effect/module.f.js";
+import { error, log, mkdir, readdir, readFile, writeFile } from "../types/effect/node/module.f.js";
 import { toOption } from "../types/nullable/module.f.js";
-import { fromVec, toVec } from "../types/uint8array/module.f.js";
-export const memKvStore = () => {
-    const create = (...i) => {
-        const store = new Map(i);
-        return {
-            read: async (key) => store.get(key),
-            write: async (...kv) => create(...store, kv),
-            list: async () => store.keys(),
-        };
-    };
-    return create();
-};
+import { unwrap } from "../types/result/module.f.js";
 const o = { withFileTypes: true };
 const split = (s) => [s.substring(0, 2), s.substring(2)];
+const prefix = '.cas';
 const toPath = (key) => {
     const s = vecToCBase32(key);
     const [a, bc] = split(s);
     const [b, c] = split(bc);
-    return `${a}/${b}/${c}`;
-};
-export const fileKvStore = (io) => (path) => {
-    const { readdir, readFile, writeFile } = io.fs.promises;
-    const { asyncTryCatch } = io;
-    const result = {
-        read: async (key) => {
-            const p = toPath(key);
-            const [s, v] = await asyncTryCatch(() => readFile(`${path}/${p}`));
-            if (s === 'error') {
-                return undefined;
-            }
-            return toVec(v);
-        },
-        write: async (key, value) => {
-            const p = toPath(key);
-            await writeFile(`${path}/${p}`, fromVec(value));
-            return result;
-        },
-        list: async () => {
-            const f = async (p) => {
-                const dir = await readdir(p, o);
-                let result = [];
-                for (const entry of dir) {
-                    const { name } = entry;
-                    if (entry.isFile()) {
-                        result = [...result, name];
-                        continue;
-                    }
-                    // directory
-                    const sub = await f(`${p}/${name}`);
-                    result = [...result, ...sub.map(x => `${name}${x}`)];
-                }
-                return result;
-            };
-            const all = await f(path);
-            return all.flatMap(compose(cBase32ToVec)(toOption));
-        },
-    };
-    return result;
+    return `${prefix}/${a}/${b}/${c}`;
 };
+export const fileKvStore = (path) => ({
+    read: (key) => readFile(toPath(key))
+        .map(([status, data]) => status === 'error' ? undefined : data),
+    write: (key, value) => {
+        const p = toPath(key);
+        const parts = parse(p);
+        const dir = `${path}/${parts.slice(0, -1).join('/')}`;
+        // TODO: error handling
+        return mkdir(dir, { recursive: true })
+            .pipe(() => writeFile(`${path}/${p}`, value))
+            .map(() => undefined);
+    },
+    list: () => readdir('.cas', { recursive: true })
+        // TODO: remove unwrap
+        .map(r => unwrap(r).flatMap(({ name, parentPath, isFile }) => toOption(isFile ? cBase32ToVec(parentPath.substring(prefix.length).replaceAll('/', '') + name) : null))),
+});
 export const cas = (sha2) => {
     const compute = computeSync(sha2);
-    const f = ({ read, list, write }) => ({
+    return ({ read, write, list }) => ({
         read,
-        write: async (value) => {
+        write: (value) => {
             const hash = compute([value]);
-            return [f(await write(hash, value)), hash];
+            return write(hash, value)
+                .map(() => hash);
         },
         list,
     });
-    return f;
+};
+const e = (s) => error(s).map(() => 1);
+export const main = (args) => {
+    const c = cas(sha256)(fileKvStore('.'));
+    const [cmd, ...options] = args;
+    switch (cmd) {
+        case 'add': {
+            if (options.length !== 1) {
+                return e("'cas add' expects one parameter");
+            }
+            const [path] = options;
+            return readFile(path)
+                .pipe(v => c.write(unwrap(v)))
+                .pipe(hash => log(vecToCBase32(hash)))
+                .map(() => 0);
+        }
+        case 'get': {
+            if (options.length !== 2) {
+                return e("'cas get' expects two parameters");
+            }
+            const [hashCBase32, path] = options;
+            const hash = cBase32ToVec(hashCBase32);
+            if (hash === null) {
+                return e(`invalid hash format: ${hashCBase32}`);
+            }
+            return c.read(hash)
+                .pipe(v => {
+                const result = v === undefined
+                    ? e(`no such hash: ${hashCBase32}`)
+                    : writeFile(path, v).map(() => 0);
+                return result;
+            });
+        }
+        case 'list': {
+            return c.list()
+                .pipe(v => {
+                // TODO: make it lazy.
+                let i = pure(undefined);
+                for (const j of v) {
+                    i = i.pipe(() => log(vecToCBase32(j)));
+                }
+                return i;
+            })
+                .map(() => 0);
+        }
+        case undefined: {
+            return e('Error: CAS command requires subcommand');
+        }
+        default:
+            return e(`Error: Unknown CAS subcommand "${args[0]}"`);
+    }
 };

package/ci/module.f.d.ts

@@ -1,3 +1,4 @@
-import type { Io } from '../io/module.f.ts';
-declare const _default: (io: Io) => Promise<number>;
+import { type NodeEffect } from '../types/effect/node/module.f.ts';
+export declare const effect: NodeEffect<number>;
+declare const _default: () => NodeEffect<number>;
 export default _default;

package/ci/module.f.js

@@ -1,4 +1,5 @@
-import { encodeUtf8 } from "../types/uint8array/module.f.js";
+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
@@ -74,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.92.0',
+                uses: 'dtolnay/rust-toolchain@1.93.0',
                 with: {
                     components: 'rustfmt,clippy',
                     targets
@@ -165,7 +166,6 @@ const gha = {
     on: { pull_request: {} },
     jobs,
 };
-export default async (io) => {
-    io.fs.writeFileSync('.github/workflows/ci.yml', encodeUtf8(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/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,5 +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 => {
@@ -9,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 })) {
@@ -47,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(decodeUtf8(await io.fs.promises.readFile(jj)));
+    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, encodeUtf8(json));
+    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) => Uint8Array;
-    readonly writeFileSync: (name: string, content: Uint8Array) => 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,17 +1,19 @@
-import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
+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(decodeUtf8(fs.readFileSync(jsonFile(name))));
-export const updateVersion = ({ fs }) => {
-    const f = (name) => {
-        return fs.writeFileSync(jsonFile(name), encodeUtf8(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,5 +1,10 @@
-import { decodeUtf8, encodeUtf8 } from "../../types/uint8array/module.f.js";
-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': {
@@ -74,15 +79,25 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-export default () => {
-    const node = {
-        fs: {
-            readFileSync: n => encodeUtf8(JSON.stringify(x[n])),
-            writeFileSync: (_, content) => decodeUtf8(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/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;