functionalscript 0.5.0 → 0.6.0

package/README.md

@@ -31,7 +31,7 @@ FunctionalScript code can be used:
 
 - safely in any JavaScript/TypeScript application or library;
 - as a JSON with expressions, see [DJS](https://medium.com/@sasha.gil/bridging-the-gap-from-json-to-javascript-without-dsls-fee273573f1b);
-- as a query language,
+- as a query language;
 - as a smart contract programming language in DeFi.
 
 ## Design Principles

package/dev/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dev/index.js

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

package/dev/module.f.d.ts

@@ -1 +1,12 @@
+import type { Io } from '../io/module.f.ts';
 export declare const todo: () => never;
+export type Module = {
+    readonly default?: unknown;
+};
+export type ModuleMap = {
+    readonly [k in string]: Module;
+};
+export declare const env: (io: Io) => (v: string) => string | undefined;
+export declare const allFiles: ({ fs: { promises: { readdir } } }: Io) => Promise<readonly string[]>;
+export declare const loadModuleMap: (io: Io) => Promise<ModuleMap>;
+export declare const index: (io: Io) => Promise<number>;

package/dev/module.f.js

@@ -1 +1,56 @@
+import { updateVersion } from "./version/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 => {
+    const r = Object.getOwnPropertyDescriptor(env, a);
+    return r === undefined ? undefined :
+        typeof r.get === 'function' ? r.get() :
+            r.value;
+};
+export const allFiles = ({ fs: { promises: { readdir } } }) => {
+    const load = async (p) => {
+        let result = [];
+        for (const i of await readdir(p, { withFileTypes: true })) {
+            const { name } = i;
+            if (!name.startsWith('.')) {
+                const file = `${p}/${name}`;
+                if (i.isDirectory()) {
+                    result = [...result, ...await load(file)];
+                    continue;
+                }
+                if (name.endsWith('.js') || name.endsWith('.ts')) {
+                    result = [...result, file];
+                }
+            }
+        }
+        return result;
+    };
+    return load('.');
+};
+export const loadModuleMap = async (io) => {
+    const { fs: { existsSync }, asyncImport } = io;
+    let map = [];
+    for (const f of await allFiles(io)) {
+        if (f.endsWith('.f.js') ||
+            (f.endsWith('.f.ts') && !existsSync(f.substring(0, f.length - 3) + '.js'))) {
+            const source = await asyncImport(`../${f}`);
+            map = [...map, [f, source]];
+        }
+    }
+    return Object.fromEntries(map.toSorted(cmp));
+};
+export const index = async (io) => {
+    updateVersion(io);
+    const jj = './deno.json';
+    const jsr_json = JSON.parse(await io.fs.promises.readFile(jj, 'utf8'));
+    const list = (await allFiles(io)).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
+    //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');
+    return 0;
+};

package/dev/test/module.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -1,10 +1,6 @@
 import type * as Result from '../../types/result/module.f.ts';
-type Module = {
-    readonly default?: unknown;
-};
-type ModuleMap = {
-    readonly [k in string]: Module;
-};
+import type { Io, Performance } from '../../io/module.f.ts';
+import { type ModuleMap } from '../module.f.ts';
 type Log<T> = (v: string) => (state: T) => T;
 type Measure<T> = <R>(f: () => R) => (state: T) => readonly [R, number, T];
 type Input<T> = {
@@ -16,5 +12,8 @@ type Input<T> = {
     readonly tryCatch: <R>(f: () => R) => Result.Result<R, unknown>;
     readonly env: (n: string) => string | undefined;
 };
-declare const _default: <T>(input: Input<T>) => readonly [number, T];
-export default _default;
+export declare const test: <T>(input: Input<T>) => readonly [number, T];
+export declare const anyLog: (f: (s: string) => void) => (s: string) => <T>(state: T) => T;
+export declare const measure: (p: Performance) => <R>(f: () => R) => <T>(state: T) => readonly [R, number, T];
+export declare const main: (io: Io) => Promise<number>;
+export {};

package/dev/test/module.f.js

@@ -1,6 +1,7 @@
 import { entries, fold } from "../../types/list/module.f.js";
 import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
-const isTest = (s) => s.endsWith('test.f.mjs') || s.endsWith('test.f.js') || s.endsWith('test.f.ts');
+import { env, loadModuleMap } from "../module.f.js";
+const isTest = (s) => s.endsWith('test.f.js') || s.endsWith('test.f.ts');
 const addPass = (delta) => (ts) => ({ ...ts, time: ts.time + delta, pass: ts.pass + 1 });
 const addFail = (delta) => (ts) => ({ ...ts, time: ts.time + delta, fail: ts.fail + 1 });
 const timeFormat = (a) => {
@@ -12,9 +13,9 @@ const timeFormat = (a) => {
     const e = x.substring(s);
     return `${b}.${e} ms`;
 };
-export default (input) => {
+export const test = (input) => {
     let { moduleMap, log, error, measure, tryCatch, env, state } = input;
-    const isGitHub = env('GITHUB_ACTION') !== void 0;
+    const isGitHub = env('GITHUB_ACTION') !== undefined;
     const f = ([k, v]) => {
         const test = i => v => ([ts, state]) => {
             const next = test(`${i}| `);
@@ -73,3 +74,22 @@ export default (input) => {
     state = log(`${bold}Time: ${timeFormat(ts.time)}${reset}`)(state);
     return [ts.fail !== 0 ? 1 : 0, state];
 };
+export const anyLog = (f) => (s) => (state) => {
+    f(s);
+    return state;
+};
+export const measure = (p) => (f) => (state) => {
+    const b = p.now();
+    const r = f();
+    const e = p.now();
+    return [r, e - b, state];
+};
+export const main = async (io) => test({
+    moduleMap: await loadModuleMap(io),
+    log: anyLog(io.console.log),
+    error: anyLog(io.console.error),
+    measure: measure(io.performance),
+    tryCatch: io.tryCatch,
+    env: env(io),
+    state: undefined,
+})[0];

package/dev/test/module.js

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

package/dev/test.f.d.ts

@@ -5,5 +5,6 @@ declare const _default: {
     number: () => void;
     properties: () => void;
     getOwnPropertyDescriptor: () => void;
+    throw: () => void;
 };
 export default _default;

package/dev/test.f.js

@@ -1,3 +1,4 @@
+import { todo } from "./module.f.js";
 export default {
     ctor: () => {
         const c = (() => { })['constructor'];
@@ -48,5 +49,8 @@ export default {
         const x = { 'a': 12 };
         const c = Object.getOwnPropertyDescriptor(x, 'constructor');
         const a = Object.getOwnPropertyDescriptor(x, 'a');
+    },
+    throw: () => {
+        todo();
     }
 };

package/{nodejs → dev}/version/module.f.d.ts

@@ -1,6 +1,6 @@
 export type Buffer = object;
 type Fs<T> = {
-    readonly readFileSync: (name: string) => Buffer;
+    readonly readFileSync: (name: string, encoding: 'utf8') => string;
     readonly writeFileSync: (name: string, content: string) => T;
 };
 export type Node<T> = {

package/{nodejs → dev}/version/module.f.js

@@ -1,7 +1,7 @@
 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)).toString());
+const readJson = fs => name => parse(fs.readFileSync(jsonFile(name), 'utf8'));
 export const updateVersion = ({ fs }) => {
     const f = (name) => {
         return fs.writeFileSync(jsonFile(name), stringify({

package/{nodejs → dev}/version/test.f.js

@@ -73,13 +73,10 @@ const e = '{\n' +
     '    "typescript": "^4.7.4"\n' +
     '  }\n' +
     '}';
-const buffer = s => ({
-    toString: () => s
-});
 export default () => {
     const node = {
         fs: {
-            readFileSync: n => buffer(JSON.stringify(x[n])),
+            readFileSync: n => JSON.stringify(x[n]),
             writeFileSync: (_, content) => content
         }
     };

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 run: ({ console: { error }, fs, process: { argv } }: Io) => void;
+export declare const compile: ({ console: { error }, fs, process: { argv } }: Io) => Promise<number>;

package/djs/module.f.js

@@ -2,11 +2,11 @@ import { transpile } from "./transpiler/module.f.js";
 import { stringify } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
 const stringifyUnknown = stringify(sort);
-export const run = ({ console: { error }, fs, process: { argv } }) => {
+export const compile = ({ console: { error }, fs, process: { argv } }) => {
     const args = argv.slice(2);
     if (args.length < 2) {
         error('Error: Requires 2 or more arguments');
-        return;
+        return Promise.resolve(1);
     }
     const inputFileName = args[0];
     const outputFileName = args[1];
@@ -22,4 +22,5 @@ export const run = ({ console: { error }, fs, process: { argv } }) => {
             break;
         }
     }
+    return Promise.resolve(0);
 };

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

@@ -1,12 +1,12 @@
 import * as result from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
 import type { DjsToken } from '../tokenizer/module.f.ts';
-import { type Map } from '../../types/map/module.f.ts';
+import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { Fs } from '../../io/module.f.ts';
 import type { AstModule } from '../ast/module.f.ts';
 export type ParseContext = {
     readonly fs: Fs;
-    readonly complete: Map<result.Result<AstModule, string>>;
+    readonly complete: OrderedMap<result.Result<AstModule, string>>;
     readonly stack: List<string>;
 };
 export declare const parseFromTokens: (tokenList: List<DjsToken>) => result.Result<AstModule, string>;

package/djs/parser/module.f.js

@@ -1,6 +1,6 @@
 import * as result from "../../types/result/module.f.js";
 import { fold, first, drop, toArray, length, concat } from "../../types/list/module.f.js";
-import { setReplace, at } from "../../types/map/module.f.js";
+import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { fromMap } from "../../types/object/module.f.js";
 const parseInitialOp = token => state => {
     switch (token.kind) {

package/djs/transpiler/module.f.d.ts

@@ -1,11 +1,11 @@
 import type * as djs from '../module.f.ts';
 import { type Result } from '../../types/result/module.f.ts';
 import { type List } from '../../types/list/module.f.ts';
-import { type Map } from '../../types/map/module.f.ts';
+import { type OrderedMap } from '../../types/ordered_map/module.f.ts';
 import type { Fs } from '../../io/module.f.ts';
 export type ParseContext = {
     readonly fs: Fs;
-    readonly complete: Map<djsResult>;
+    readonly complete: OrderedMap<djsResult>;
     readonly stack: List<string>;
     readonly error: string | null;
 };

package/djs/transpiler/module.f.js

@@ -1,7 +1,7 @@
 import { error, ok } from "../../types/result/module.f.js";
 import { fold, drop, map as listMap, toArray, includes } from "../../types/list/module.f.js";
 import { tokenize } from "../tokenizer/module.f.js";
-import { setReplace, at } from "../../types/map/module.f.js";
+import { setReplace, at } from "../../types/ordered_map/module.f.js";
 import { stringToList } from "../../text/utf16/module.f.js";
 import { concat as pathConcat } from "../../path/module.f.js";
 import { parseFromTokens } from "../parser/module.f.js";

package/djs/transpiler/test.f.js

@@ -1,8 +1,8 @@
 import { sort } from "../../types/object/module.f.js";
-import { setReplace } from "../../types/map/module.f.js";
+import { setReplace } from "../../types/ordered_map/module.f.js";
 import { transpile } from "./module.f.js";
 import { stringify } from "../serializer/module.f.js";
-import { createVirtualIo } from "../../io/virtual-io.f.js";
+import { createVirtualIo } from "../../io/virtual.f.js";
 const virtualFs = map => {
     return createVirtualIo(map).fs;
 };

package/fsc/module.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/fsc/module.js

@@ -0,0 +1,4 @@
+#!/usr/bin/env node
+import node from "../io/module.js";
+import { compile } from "../djs/module.f.js";
+await node(compile);

package/io/module.d.ts

@@ -0,0 +1,4 @@
+import { type Io, type Run } from './module.f.ts';
+export declare const io: Io;
+declare const runDefault: Run;
+export default runDefault;

package/io/module.f.d.ts

@@ -1,17 +1,85 @@
+import type { Result } from '../types/result/module.f.ts';
+/**
+ * Standard Node.js buffer encoding type
+ * @see https://nodejs.org/api/buffer.html#buffer_buffers_and_character_encodings
+ */
 export type BufferEncoding = 'utf8';
+/**
+ * Represents a directory entry (file or directory) in the filesystem
+ * @see https://nodejs.org/api/fs.html#class-fsdirent
+ */
+export type Dirent = {
+    readonly name: string;
+    readonly isDirectory: () => boolean;
+    readonly isFile: () => boolean;
+};
+/**
+ * File system operations interface
+ * @see https://nodejs.org/api/fs.html
+ */
 export type Fs = {
     readonly writeFileSync: (file: string, data: string) => void;
     readonly readFileSync: (path: string, options: BufferEncoding) => string | null;
+    readonly existsSync: (path: string) => boolean;
+    readonly promises: {
+        readonly readFile: (path: string, options: BufferEncoding) => Promise<string>;
+        readonly writeFile: (path: string, data: string, options: BufferEncoding) => Promise<void>;
+        readonly readdir: (path: string, options: {
+            withFileTypes: true;
+        }) => Promise<Dirent[]>;
+    };
 };
+/**
+ * Console operations interface
+ * @see https://nodejs.org/api/console.html
+ */
 export type Console = {
     readonly log: (...d: unknown[]) => void;
     readonly error: (...d: unknown[]) => void;
 };
+/**
+ * Represents an ES module with a default export
+ */
+export type Module = {
+    readonly default: unknown;
+};
+/**
+ * High-resolution time measurement interface
+ * @see https://nodejs.org/api/perf_hooks.html#performance-now
+ */
+export type Performance = {
+    readonly now: () => number;
+};
+/**
+ * Core IO operations interface providing access to system resources
+ */
 export type Io = {
     readonly console: Console;
     readonly fs: Fs;
     readonly process: Process;
+    readonly asyncImport: (s: string) => Promise<Module>;
+    readonly performance: Performance;
+    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
+    readonly asyncTryCatch: <T>(f: () => Promise<T>) => Promise<Result<T, unknown>>;
 };
+/**
+ * Node.js Process interface
+ * @see https://nodejs.org/api/process.html
+ */
 export type Process = {
     readonly argv: string[];
+    readonly env: Env;
+    readonly exit: (code: number) => never;
+};
+/**
+ * The environment variables.
+ */
+export type Env = {
+    readonly [k: string]: string | undefined;
 };
+export type Run = (f: (io: Io) => Promise<number>) => Promise<never>;
+/**
+ * Runs a function and exits the process with the returned code
+ * Handles errors by exiting with code 1
+ */
+export declare const run: (io: Io) => Run;

package/io/module.f.js

@@ -1 +1,16 @@
-export {};
+/**
+ * Runs a function and exits the process with the returned code
+ * Handles errors by exiting with code 1
+ */
+export const run = (io) => {
+    const code = ([x, b]) => {
+        if (x === 'error') {
+            io.console.error(x[1]);
+            return 1;
+        }
+        else {
+            return b;
+        }
+    };
+    return async (f) => io.process.exit(code(await io.asyncTryCatch(() => f(io))));
+};

package/io/module.js

@@ -0,0 +1,36 @@
+var __rewriteRelativeImportExtension = (this && this.__rewriteRelativeImportExtension) || function (path, preserveJsx) {
+    if (typeof path === "string" && /^\.\.?\//.test(path)) {
+        return path.replace(/\.(tsx)$|((?:\.d)?)((?:\.[^./]+?)?)\.([cm]?)ts$/i, function (m, tsx, d, ext, cm) {
+            return tsx ? preserveJsx ? ".jsx" : ".js" : d && (!ext || !cm) ? m : (d + ext + "." + cm.toLowerCase() + "js");
+        });
+    }
+    return path;
+};
+import { run } from "./module.f.js";
+import fs from 'node:fs';
+import process from "node:process";
+export const io = {
+    console,
+    fs,
+    process,
+    asyncImport: (v) => import(__rewriteRelativeImportExtension(v)),
+    performance,
+    tryCatch: f => {
+        try {
+            return ['ok', f()];
+        }
+        catch (e) {
+            return ['error', e];
+        }
+    },
+    asyncTryCatch: async (f) => {
+        try {
+            return ['ok', await f()];
+        }
+        catch (e) {
+            return ['error', e];
+        }
+    },
+};
+const runDefault = run(io);
+export default runDefault;

package/io/virtual.f.d.ts

@@ -0,0 +1,3 @@
+import type { Io } from './module.f.ts';
+import { type OrderedMap } from '../types/ordered_map/module.f.ts';
+export declare const createVirtualIo: (files: OrderedMap<string>) => Io;

package/io/virtual.f.js

@@ -0,0 +1,28 @@
+import { at } from "../types/ordered_map/module.f.js";
+export const createVirtualIo = (files) => ({
+    console: {
+        log: (..._d) => { },
+        error: (..._d) => { }
+    },
+    fs: {
+        writeFileSync: (_file, _data) => { },
+        readFileSync: (path, _options) => { return at(path)(files); },
+        existsSync: (path) => { return at(path)(files) !== null; },
+        promises: {
+            readdir: (_path) => Promise.resolve([]),
+            readFile: (_path, _options) => Promise.resolve(''),
+            writeFile: (_path, _data, _options) => Promise.resolve(),
+        }
+    },
+    process: {
+        argv: [],
+        env: {},
+        exit: n => { throw n; },
+    },
+    asyncImport: () => Promise.reject(),
+    performance: {
+        now: () => 0,
+    },
+    tryCatch: f => ['ok', f()],
+    asyncTryCatch: async (f) => ['ok', await f()],
+});

package/js/tokenizer/module.f.js

@@ -2,7 +2,7 @@ import * as operator from "../../types/function/operator/module.f.js";
 import * as range_map from "../../types/range_map/module.f.js";
 const { merge, fromRange, get } = range_map;
 import * as list from "../../types/list/module.f.js";
-import * as map from "../../types/map/module.f.js";
+import * as map from "../../types/ordered_map/module.f.js";
 const { at } = map;
 import * as _range from "../../types/range/module.f.js";
 const { one } = _range;

package/json/parser/module.f.d.ts

@@ -1,5 +1,5 @@
 import * as result from '../../types/result/module.f.ts';
-import * as list from '../../types/list/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
 import type * as Tokenizer from '../tokenizer/module.f.ts';
 import type * as Json from '../module.f.ts';
-export declare const parse: (tokenList: list.List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;
+export declare const parse: (tokenList: List<Tokenizer.JsonToken>) => result.Result<Json.Unknown, string>;

package/json/parser/module.f.js

@@ -1,13 +1,10 @@
 import * as result from "../../types/result/module.f.js";
-import * as list from "../../types/list/module.f.js";
-const { fold, first, drop, toArray } = list;
-import * as map from "../../types/map/module.f.js";
-const { setReplace } = map;
-import * as o from "../../types/object/module.f.js";
-const { fromMap } = o;
+import { fold, first, drop, toArray, concat } from "../../types/list/module.f.js";
+import { setReplace } from "../../types/ordered_map/module.f.js";
+import { fromMap } from "../../types/object/module.f.js";
 const addKeyToObject = obj => key => ({ kind: 'object', values: obj.values, key: key });
 const addValueToObject = obj => value => ({ kind: 'object', values: setReplace(obj.key)(value)(obj.values), key: '' });
-const addToArray = array => value => ({ kind: 'array', values: list.concat(array.values)([value]) });
+const addToArray = array => value => ({ kind: 'array', values: concat(array.values)([value]) });
 const pushKey = state => value => {
     if (state.top?.kind === 'object') {
         return { status: '{k', top: addKeyToObject(state.top)(value), stack: state.stack };

package/package.json

@@ -1,29 +1,29 @@
 {
   "name": "functionalscript",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "type": "module",
   "files": [
-    "fsc.js",
-    "io/node-io.js",
-    "**/*.f.d.ts",
-    "**/*.f.js"
+    "**/*.js",
+    "**/*.d.ts"
   ],
   "description": "FunctionalScript is a functional subset of JavaScript",
   "scripts": {
     "tsc-emit": "tsc --NoEmit false",
-    "n": "node --frozen-intrinsics --trace-uncaught",
+    "n": "node --trace-uncaught",
     "prepack": "npm run tsc-emit",
     "git-clean": "git clean -xf",
-    "test20": "npm run tsc-emit && npm run n ./dev/test.js",
-    "test22": "tsc && npm run n -- --experimental-strip-types ./dev/test.ts",
-    "test": "tsc && npm run n ./dev/test.ts",
+    "test20": "npm run tsc-emit && npm run n ./dev/test/module.js",
+    "test22": "tsc && npm run n -- --experimental-strip-types ./dev/test/module.ts",
+    "test": "tsc && npm run n ./dev/test/module.ts",
     "index": "npm run n ./dev/index.ts",
-    "version": "npm run n ./nodejs/version/main.ts",
-    "fsc": "npm run n ./fsc.ts",
-    "update": "npm run version && npm run index && npm install"
+    "fsc": "npm run n ./fsc/module.ts",
+    "update": "npm run index && npm install"
+  },
+  "engines": {
+    "node": ">=16"
   },
   "bin": {
-    "fsc": "fsc.js"
+    "fsc": "fsc/module.js"
   },
   "repository": {
     "type": "git",
@@ -45,7 +45,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.13.10",
-    "typescript": "^5.8.2"
+    "@types/node": "^22.14",
+    "typescript": "^5.8.3"
   }
 }

package/types/map/module.f.d.ts

@@ -1,12 +1,2 @@
-import type { Tree } from '../btree/types/module.f.ts';
-import { type List } from '../list/module.f.ts';
-import type { Reduce } from '../function/operator/module.f.ts';
-export type Entry<T> = readonly [string, T];
-export type Map<T> = Tree<Entry<T>>;
-export declare const at: (name: string) => <T>(map: Map<T>) => T | null;
-export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: Map<T>) => Map<T>;
-export declare const setReplace: (name: string) => <T>(value: T) => (map: Map<T>) => Map<T>;
-export declare const entries: <T>(map: Map<T>) => List<Entry<T>>;
-export declare const fromEntries: <T>(entries: List<Entry<T>>) => Map<T>;
-export declare const remove: (name: string) => <T>(map: Map<T>) => Map<T>;
-export declare const empty: null;
+export declare const mapSet: <K, V>(map: ReadonlyMap<K, V>, k: K, v: V) => ReadonlyMap<K, V>;
+export declare const mapDelete: <K, V>(map: ReadonlyMap<K, V>, k: K) => ReadonlyMap<K, V>;

package/types/map/module.f.js

@@ -1,22 +1,17 @@
-import { value, find } from "../btree/find/module.f.js";
-import { set } from "../btree/set/module.f.js";
-import { remove as btreeRemove } from "../btree/remove/module.f.js";
-import { values } from "../btree/module.f.js";
-import { cmp } from "../string/module.f.js";
-import { fold } from "../list/module.f.js";
-const keyCmp = a => ([b]) => cmp(a)(b);
-export const at = (name) => (map) => {
-    if (map === null) {
-        return null;
+const concat = (x, y) => ({
+    *[Symbol.iterator]() {
+        yield* x;
+        yield* y;
     }
-    const result = value(find(keyCmp(name))(map).first);
-    return result === null ? null : result[1];
-};
-const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])]);
-export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value]);
-const replace = () => b => b;
-export const setReplace = name => value => setReduceEntry(replace)([name, value]);
-export const entries = values;
-export const fromEntries = fold(setReduceEntry(replace))(null);
-export const remove = name => btreeRemove(keyCmp(name));
-export const empty = null;
+});
+const filter = (i, p) => ({
+    *[Symbol.iterator]() {
+        for (const x of i) {
+            if (p(x)) {
+                yield x;
+            }
+        }
+    }
+});
+export const mapSet = (map, k, v) => new Map(concat(map, [[k, v]]));
+export const mapDelete = (map, k) => new Map(filter(map, ([xk]) => xk !== k));

package/types/map/test.f.d.ts

@@ -1,5 +1,5 @@
 declare const _default: {
-    main: (() => void)[];
-    stress: () => void;
+    set: () => void;
+    delete: () => void;
 };
 export default _default;

package/types/map/test.f.js

@@ -1,113 +1,21 @@
-import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
-import { toArray } from "../list/module.f.js";
+import { mapSet, mapDelete } from "./module.f.js";
 export default {
-    main: [
-        () => {
-            let m = setReplace('a')(1)(null);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== null) {
-                throw 'error';
-            }
-            m = setReplace('b')(2)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('c')(m) !== null) {
-                throw 'error';
-            }
-            m = setReplace('z')(3)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== null) {
-                throw 'error';
-            }
-            m = setReplace('')(4)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== 4) {
-                throw 'error';
-            }
-            if (at('Hello world!')(m) !== null) {
-                throw 'error';
-            }
-            m = setReplace('Hello world!')(42)(m);
-            if (at('a')(m) !== 1) {
-                throw 'error';
-            }
-            if (at('b')(m) !== 2) {
-                throw 'error';
-            }
-            if (at('z')(m) !== 3) {
-                throw 'error';
-            }
-            if (at('')(m) !== 4) {
-                throw 'error';
-            }
-            if (at('Hello world!')(m) !== 42) {
-                throw 'error';
-            }
-            if (at('x')(m) !== null) {
-                throw 'error';
-            }
-            // console.log(Array.from(m.entries()))
-            m = remove('Hello world!')(m);
-            if (at('Hello world!')(m) !== null) {
-                throw m;
-            }
-            m = setReduce((a) => (b) => a + b)('a')(43)(m);
-            if (at('a')(m) !== 44) {
-                throw 'error';
-            }
-        },
-        () => {
-            let m = setReplace('x')(12)(null);
-            m = setReplace('y')(44)(m);
-            if (at('x')(m) !== 12) {
-                throw 'error';
-            }
-            if (at('y')(m) !== 44) {
-                throw 'error';
-            }
-            if (at('a')(m) !== null) {
-                throw 'error';
-            }
-            const e = toArray(entries(m));
-            if (e.length !== 2) {
-                throw 'error';
-            }
-        },
-    ],
-    stress: () => {
-        let m = empty;
-        for (let i = 0; i < 100_000; ++i) {
-            m = setReplace((i * i).toString())(i)(m);
-            /*
-            console.log()
-            console.log(`# ${i}`)
-            console.log()
-            for (const e of m.struct()) {
-                console.log(e)
-            }
-            */
+    set: () => {
+        const map = mapSet(new Map(), 'a', 'b');
+        if (map.get('a') !== 'b') {
+            throw 'error';
+        }
+        if (map.size !== 1) {
+            throw 'error';
+        }
+    },
+    delete: () => {
+        const map = mapDelete(mapSet(new Map(), 'a', 'b'), 'a');
+        if (map.get('a') !== undefined) {
+            throw 'error';
+        }
+        if (map.size !== 0) {
+            throw 'error';
         }
     }
 };

package/types/object/module.f.d.ts

@@ -1,5 +1,5 @@
 import { type List } from '../list/module.f.ts';
-import { type Map as BtMap } from '../map/module.f.ts';
+import { type OrderedMap } from '../ordered_map/module.f.ts';
 export type Map<T> = {
     readonly [k in string]: T;
 };
@@ -7,7 +7,7 @@ export type Entry<T> = readonly [string, T];
 export declare const at: (name: string) => <T>(object: Map<T>) => T | null;
 export declare const sort: <T>(e: List<Entry<T>>) => List<Entry<T>>;
 export declare const fromEntries: <T>(e: List<Entry<T>>) => Map<T>;
-export declare const fromMap: <T>(m: BtMap<T>) => Map<T>;
+export declare const fromMap: <T>(m: OrderedMap<T>) => Map<T>;
 /**
  * A set of objects with a single key.
  *

package/types/object/module.f.js

@@ -1,5 +1,5 @@
 import { iterable } from "../list/module.f.js";
-import { entries as mapEntries, fromEntries as mapFromEntries } from "../map/module.f.js";
+import { entries as mapEntries, fromEntries as mapFromEntries } from "../ordered_map/module.f.js";
 const { getOwnPropertyDescriptor, fromEntries: objectFromEntries } = Object;
 export const at = name => object => {
     const r = getOwnPropertyDescriptor(object, name);

package/types/ordered_map/module.f.d.ts

@@ -0,0 +1,12 @@
+import type { Tree } from '../btree/types/module.f.ts';
+import { type List } from '../list/module.f.ts';
+import type { Reduce } from '../function/operator/module.f.ts';
+export type Entry<T> = readonly [string, T];
+export type OrderedMap<T> = Tree<Entry<T>>;
+export declare const at: (name: string) => <T>(map: OrderedMap<T>) => T | null;
+export declare const setReduce: <T>(reduce: Reduce<T>) => (name: string) => (value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
+export declare const setReplace: (name: string) => <T>(value: T) => (map: OrderedMap<T>) => OrderedMap<T>;
+export declare const entries: <T>(map: OrderedMap<T>) => List<Entry<T>>;
+export declare const fromEntries: <T>(entries: List<Entry<T>>) => OrderedMap<T>;
+export declare const remove: (name: string) => <T>(map: OrderedMap<T>) => OrderedMap<T>;
+export declare const empty: null;

package/types/ordered_map/module.f.js

@@ -0,0 +1,22 @@
+import { value, find } from "../btree/find/module.f.js";
+import { set } from "../btree/set/module.f.js";
+import { remove as btreeRemove } from "../btree/remove/module.f.js";
+import { values } from "../btree/module.f.js";
+import { cmp } from "../string/module.f.js";
+import { fold } from "../list/module.f.js";
+const keyCmp = a => ([b]) => cmp(a)(b);
+export const at = (name) => (map) => {
+    if (map === null) {
+        return null;
+    }
+    const result = value(find(keyCmp(name))(map).first);
+    return result === null ? null : result[1];
+};
+const setReduceEntry = reduce => entry => set(keyCmp(entry[0]))(old => old === null ? entry : [old[0], reduce(old[1])(entry[1])]);
+export const setReduce = reduce => name => value => setReduceEntry(reduce)([name, value]);
+const replace = () => b => b;
+export const setReplace = name => value => setReduceEntry(replace)([name, value]);
+export const entries = values;
+export const fromEntries = fold(setReduceEntry(replace))(null);
+export const remove = name => btreeRemove(keyCmp(name));
+export const empty = null;

package/types/ordered_map/test.f.d.ts

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

package/types/ordered_map/test.f.js

@@ -0,0 +1,113 @@
+import { at, setReplace, setReduce, empty, entries, remove } from "./module.f.js";
+import { toArray } from "../list/module.f.js";
+export default {
+    main: [
+        () => {
+            let m = setReplace('a')(1)(null);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('b')(2)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('c')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('z')(3)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('')(4)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== 4) {
+                throw 'error';
+            }
+            if (at('Hello world!')(m) !== null) {
+                throw 'error';
+            }
+            m = setReplace('Hello world!')(42)(m);
+            if (at('a')(m) !== 1) {
+                throw 'error';
+            }
+            if (at('b')(m) !== 2) {
+                throw 'error';
+            }
+            if (at('z')(m) !== 3) {
+                throw 'error';
+            }
+            if (at('')(m) !== 4) {
+                throw 'error';
+            }
+            if (at('Hello world!')(m) !== 42) {
+                throw 'error';
+            }
+            if (at('x')(m) !== null) {
+                throw 'error';
+            }
+            // console.log(Array.from(m.entries()))
+            m = remove('Hello world!')(m);
+            if (at('Hello world!')(m) !== null) {
+                throw m;
+            }
+            m = setReduce((a) => (b) => a + b)('a')(43)(m);
+            if (at('a')(m) !== 44) {
+                throw 'error';
+            }
+        },
+        () => {
+            let m = setReplace('x')(12)(null);
+            m = setReplace('y')(44)(m);
+            if (at('x')(m) !== 12) {
+                throw 'error';
+            }
+            if (at('y')(m) !== 44) {
+                throw 'error';
+            }
+            if (at('a')(m) !== null) {
+                throw 'error';
+            }
+            const e = toArray(entries(m));
+            if (e.length !== 2) {
+                throw 'error';
+            }
+        },
+    ],
+    stress: () => {
+        let m = empty;
+        for (let i = 0; i < 100_000; ++i) {
+            m = setReplace((i * i).toString())(i)(m);
+            /*
+            console.log()
+            console.log(`# ${i}`)
+            console.log()
+            for (const e of m.struct()) {
+                console.log(e)
+            }
+            */
+        }
+    }
+};

package/types/result/module.d.ts

@@ -0,0 +1,5 @@
+import { type Result } from './module.f.ts';
+declare const _default: {
+    readonly tryCatch: <T>(f: () => T) => Result<T, unknown>;
+};
+export default _default;

package/types/result/module.js

@@ -0,0 +1,13 @@
+import { ok, error } from "./module.f.js";
+const tryCatch = f => {
+    // Side effect: `try catch` is not allowed in FunctionalScript.
+    try {
+        return ok(f());
+    }
+    catch (e) {
+        return error(e);
+    }
+};
+export default {
+    tryCatch,
+};

package/fsc.js

@@ -1,4 +0,0 @@
-#!/usr/bin/env node
-import io from "./io/node-io.js";
-import { run } from "./djs/module.f.js";
-run(io);

package/io/node-io.js

@@ -1,7 +0,0 @@
-import fs from 'node:fs';
-import process from "node:process";
-export default {
-    console,
-    fs,
-    process
-};

package/io/virtual-io.f.d.ts

@@ -1,3 +0,0 @@
-import type { Io } from './module.f.ts';
-import { type Map } from '../types/map/module.f.ts';
-export declare const createVirtualIo: (files: Map<string>) => Io;

package/io/virtual-io.f.js

@@ -1,14 +0,0 @@
-import { at } from "../types/map/module.f.js";
-export const createVirtualIo = (files) => ({
-    console: {
-        log: (..._d) => { },
-        error: (..._d) => { }
-    },
-    fs: {
-        writeFileSync: (_file, _data) => { },
-        readFileSync: (path, _options) => { return at(path)(files); }
-    },
-    process: {
-        argv: []
-    }
-});