functionalscript 0.5.1 → 0.6.1

package/dev/index/module.d.ts

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

package/dev/index/module.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,22 +1,12 @@
 import type { Io } from '../io/module.f.ts';
-import type { Sign } from '../types/function/compare/module.f.ts';
 export declare const todo: () => never;
 export type Module = {
     readonly default?: unknown;
 };
-export type UnknownMap = {
-    readonly [k in string]: unknown;
-};
-type Entry<T> = readonly [string, T];
-export declare const cmp: ([a]: Entry<unknown>, [b]: Entry<unknown>) => Sign;
 export type ModuleMap = {
     readonly [k in string]: Module;
 };
-export declare const remove_tail: (v: readonly string[]) => (dif: number) => string[];
-export type MutableModuleMap = {
-    [k in string]: Module;
-};
 export declare const env: (io: Io) => (v: string) => string | undefined;
-export declare const loadModuleMap: ({ fs: { promises: { readdir }, existsSync }, asyncImport }: Io) => Promise<ModuleMap>;
+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>;
-export {};

package/dev/module.f.js

@@ -1,77 +1,51 @@
 import { updateVersion } from "./version/module.f.js";
 export const todo = () => { throw 'not implemented'; };
-export const cmp = ([a], [b]) => a < b ? -1 : a > b ? 1 : 0;
-export const remove_tail = (v) => (dif) => v.slice(0, v.length - dif);
+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 loadModuleMap = async ({ fs: { promises: { readdir }, existsSync }, asyncImport }) => {
-    const load = async () => {
-        const map = [];
-        const f = async (p) => {
-            for (const i of await readdir(p, { withFileTypes: true })) {
-                const { name } = i;
-                if (!name.startsWith('.')) {
-                    const file = `${p}/${name}`;
-                    if (i.isDirectory()) {
-                        await f(file);
-                        continue;
-                    }
-                    if (name.endsWith('.f.mjs') ||
-                        name.endsWith('.f.js') ||
-                        (name.endsWith('.f.ts') && !existsSync(file.substring(0, file.length - 3) + '.js'))) {
-                        const source = await asyncImport(`../${file}`);
-                        map.push([file, source.default]);
-                    }
+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;
                 }
-            }
-        };
-        await f('.');
-        map.sort(cmp);
-        return Object.fromEntries(map);
-    };
-    const map = await load();
-    const build = () => {
-        const d = {};
-        const getModule = (base) => (k) => {
-            const relativePath = k.split('/');
-            const dif = relativePath.filter(v => v === '..').length;
-            const path = [remove_tail(base)(dif), relativePath.filter(v => !['..', '.'].includes(v))]
-                .flat();
-            const pathStr = path.join('/');
-            {
-                const module = d[pathStr];
-                if (module !== void 0) {
-                    return [pathStr, module];
+                if (name.endsWith('.js') || name.endsWith('.ts')) {
+                    result = [...result, file];
                 }
             }
-            {
-                const module = { default: map[pathStr] };
-                d[pathStr] = module;
-                return [pathStr, module];
-            }
-        };
-        {
-            const get = getModule(['.']);
-            for (const k of Object.keys(map)) {
-                get(k);
-            }
         }
-        return d;
+        return result;
     };
-    return build();
+    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 n = '/module.f.ts';
     const jsr_json = JSON.parse(await io.fs.promises.readFile(jj, 'utf8'));
-    const list = Object.keys(await loadModuleMap(io)).filter(v => v.endsWith(n));
+    const list = (await allFiles(io)).filter(v => v.endsWith('/module.f.ts') || v.endsWith('/module.ts'));
     //console.log(list)
-    const exportsA = list.filter(v => !v.startsWith('./out')).map(v => [v.replace(n, ''), `./${v.substring(2)}`]);
+    const exportsA = list.map(v => [v, `./${v.substring(2)}`]);
     // console.log(exportsA)
     const exports = Object.fromEntries(exportsA);
     // console.log(exports)

package/dev/test/module.d.ts

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

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

@@ -1,11 +1,6 @@
 import type * as Result from '../../types/result/module.f.ts';
 import type { Io, Performance } from '../../io/module.f.ts';
-type Module = {
-    readonly default?: unknown;
-};
-type ModuleMap = {
-    readonly [k in string]: Module;
-};
+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> = {

package/dev/test/module.f.js

@@ -1,7 +1,7 @@
 import { entries, fold } from "../../types/list/module.f.js";
 import { reset, fgGreen, fgRed, bold } from "../../text/sgr/module.f.js";
 import { env, loadModuleMap } from "../module.f.js";
-const isTest = (s) => s.endsWith('test.f.mjs') || s.endsWith('test.f.js') || s.endsWith('test.f.ts');
+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) => {
@@ -15,7 +15,7 @@ const timeFormat = (a) => {
 };
 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}| `);
@@ -91,5 +91,5 @@ export const main = async (io) => test({
     measure: measure(io.performance),
     tryCatch: io.tryCatch,
     env: env(io),
-    state: void 0,
+    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/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,5 +1,5 @@
 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.f.js";

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

@@ -13,6 +13,13 @@ export type Dirent = {
     readonly isDirectory: () => boolean;
     readonly isFile: () => boolean;
 };
+export type RmOptions = {
+    readonly force?: boolean;
+    readonly recursive?: boolean;
+};
+export type MakeDirectoryOptions = {
+    readonly recursive?: boolean;
+};
 /**
  * File system operations interface
  * @see https://nodejs.org/api/fs.html
@@ -27,6 +34,9 @@ export type Fs = {
         readonly readdir: (path: string, options: {
             withFileTypes: true;
         }) => Promise<Dirent[]>;
+        readonly rm: (path: string, options?: RmOptions) => Promise<void>;
+        readonly mkdir: (path: string, options?: MakeDirectoryOptions) => Promise<string | undefined>;
+        readonly copyFile: (src: string, dest: string) => Promise<void>;
     };
 };
 /**
@@ -77,7 +87,8 @@ export type Process = {
 export type Env = {
     readonly [k: string]: string | undefined;
 };
-export type Run = (f: (io: Io) => Promise<number>) => Promise<never>;
+export type App = (io: Io) => Promise<number>;
+export type Run = (f: App) => Promise<never>;
 /**
  * Runs a function and exits the process with the returned code
  * Handles errors by exiting with code 1

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

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

package/io/virtual.f.js

@@ -1,4 +1,4 @@
-import { at } from "../types/map/module.f.js";
+import { at } from "../types/ordered_map/module.f.js";
 export const createVirtualIo = (files) => ({
     console: {
         log: (..._d) => { },
@@ -12,6 +12,9 @@ export const createVirtualIo = (files) => ({
             readdir: (_path) => Promise.resolve([]),
             readFile: (_path, _options) => Promise.resolve(''),
             writeFile: (_path, _data, _options) => Promise.resolve(),
+            rm: (_path, _options) => Promise.resolve(),
+            mkdir: (_path, _options) => Promise.resolve(undefined),
+            copyFile: (_src, _dest) => Promise.resolve(),
         }
     },
     process: {

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,31 +1,29 @@
 {
   "name": "functionalscript",
-  "version": "0.5.1",
+  "version": "0.6.1",
   "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",
-    "index": "npm run n ./dev/index.ts",
-    "fsc": "npm run n ./fsc.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/module.ts",
+    "fsc": "npm run n ./fsc/module.ts",
     "update": "npm run index && npm install"
   },
   "engines": {
-    "node": ">=16"
+    "node": ">=20"
   },
   "bin": {
-    "fsc": "fsc.js"
+    "fsc": "fsc/module.js"
   },
   "repository": {
     "type": "git",
@@ -47,7 +45,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.13.14",
-    "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 node from "./io/node.js";
-import { compile } from "./djs/module.f.js";
-await node(compile);