functionalscript 0.2.0 → 0.2.1

package/out/com/rust/module.f.mjs

@@ -0,0 +1,213 @@
+// @ts-self-types="./module.f.d.mts"
+import * as types from '../types/module.f.mjs';
+const { paramList } = types;
+import * as Text from '../../text/module.f.mjs';
+import * as O from '../../types/object/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+const { flat, map, flatMap } = list;
+const { entries } = Object;
+import * as func from '../../types/function/module.f.mjs';
+const { fn } = func;
+import * as string from '../../types/string/module.f.mjs';
+const { join } = string;
+/** @type {(field: string) => string} */
+const rustField = field => `pub ${field},`;
+const mapRustField = map(rustField);
+/** @type {(b: list.Thunk<string>) => (name: string) => Text.Block} */
+const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
+const commaJoin = join(', ');
+/** @type {(name: string) => string} */
+const ref = name => `${name}::Ref`;
+/** @type {(name: string) => string} */
+const obj = name => `&${name}::Object`;
+const self = ['&self'];
+/** @type {(p: types.Field) => string} */
+const paramName = ([n]) => n;
+/** @type {(p: types.FieldArray) => list.Thunk<string>} */
+const callList = p => map(paramName)(paramList(p));
+/** @type {(p: types.FieldArray) => string} */
+const call = p => commaJoin(callList(p));
+/** @type {(p: types.FieldArray) => string} */
+const virtualCall = p => commaJoin(flat([['self'], callList(p)]));
+const super_ = 'super::';
+/** @type {(m: types.Method) => string} */
+const assign = ([n]) => `${n}: Self::${n},`;
+const mapAssign = map(assign);
+const this_ = ['this: &Object'];
+/** @type {(n: string) => string} */
+const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`;
+/**
+ * @template T
+ * @typedef {T|{}} OptionalProperty
+ */
+/** @typedef {{readonly where: readonly string[]}} Where */
+/**
+ * @typedef {OptionalProperty<Where> & {readonly content: Text.Block}} WhereContent
+ */
+/** @type {(h: string) => (wh: WhereContent) => Text.Block} */
+const whereContent = h => wh => {
+    const w = 'where' in wh ? [
+        h,
+        `where`,
+        mapComma(wh.where),
+        '{'
+    ] : [`${h} {`];
+    const x = [
+        wh.content,
+        '}',
+    ];
+    return flat([w, x]);
+};
+/**
+ * @typedef {{
+ *  readonly param?: string
+ *  readonly trait: string
+ *  readonly type: string
+ *  readonly where?: readonly string[]
+ *  readonly content: Text.Block
+ * }} Impl
+ */
+/** @type {(impl: Impl) => Text.Block} */
+const rustImpl = i => {
+    const p = 'param' in i ? `<${i.param}>` : '';
+    const header = `impl${p} ${i.trait} for ${i.type}`;
+    return whereContent(header)(i);
+};
+/**
+ * @typedef {{
+ *  readonly pub?: true
+ *  readonly type: string
+ *  readonly where?: readonly string[]
+ *  readonly content: Text.Block
+ * }} Trait
+ */
+/** @type {(s: string) => string} */
+const comma = s => `${s},`;
+const mapComma = map(comma);
+/** @type {(t: Trait) => Text.Block} */
+const trait = t => {
+    const p = t.pub === true ? 'pub ' : '';
+    const h = `${p}trait ${t.type}`;
+    return whereContent(h)(t);
+};
+/** @type {(t: Trait) => Text.Block} */
+const traitImpl = t => {
+    const i = rustImpl({
+        param: 'T',
+        trait: t.type,
+        type: 'T',
+        where,
+        content: [],
+    });
+    return flat([trait({ ...t, where }), i]);
+};
+const where = ['Self: nanocom::Class<Interface = Interface>', 'nanocom::CObject<Self>: Ex'];
+/** @type {(library: types.Library) => Text.Block} */
+export const rust = library => {
+    /** @type {(p: string) => (o: (_: string) => string) => (t: types.Type) => string} */
+    const type = p => {
+        /** @type {(o: (_: string) => string) => (t: types.Type) => string} */
+        const f = o => t => {
+            if (typeof t === 'string') {
+                return t;
+            }
+            if (t.length === 2) {
+                return `*const ${f(ref)(t[1])}`;
+            }
+            const [id] = t;
+            const fullId = `${p}${id}`;
+            return 'interface' in library[id] ? o(fullId) : fullId;
+        };
+        return f;
+    };
+    /** @type {(p: string) => (o: (_: string) => string) => (f: types.Field) => string} */
+    const pf = p => o => ([name, t]) => `${name}: ${type(p)(o)(t)}`;
+    const param = pf(super_)(obj);
+    const mapParam = map(param);
+    const mapField = map(pf('')(ref));
+    /** @type {(fa: types.FieldArray) => (name: string) => Text.Block} */
+    const struct = fn(entries)
+        .then(mapField)
+        .then(rustStruct)
+        .result;
+    /** @type {(first: readonly string[]) => (p: types.FieldArray) => string} */
+    const func = first => p => {
+        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : '';
+        const params = commaJoin(flat([first, mapParam(paramList(p))]));
+        return `(${params})${resultStr}`;
+    };
+    /** @type {(n: string) => (p: types.FieldArray) => string} */
+    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`;
+    /** @type {(m: types.Method) => string} */
+    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`;
+    const mapVirtualFn = map(virtualFn);
+    /** @type {(m: types.Method) => string} */
+    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`;
+    /** @type {(m: types.Method) => string} */
+    const traitFn = m => `${headerFn(m)};`;
+    const mapTraitFn = map(traitFn);
+    /** @type {(m: types.Method) => Text.Block} */
+    const implFn = m => {
+        const [n, p] = m;
+        return [
+            `${headerFn(m)} {`,
+            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
+            '}'
+        ];
+    };
+    const flatMapImplFn = flatMap(implFn);
+    /** @type {(m: types.Method) => Text.Block} */
+    const impl = ([n, p]) => {
+        const type = virtualFnType(` ${n}`)(p);
+        return [
+            `${type} {`,
+            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
+            '}'
+        ];
+    };
+    const flatMapImpl = flatMap(impl);
+    /** @type {(i: types.Interface) => (name: string) => Text.Block} */
+    const interface_ = ({ interface: i, guid }) => name => {
+        const e = entries(i);
+        return [
+            `pub mod ${name} {`,
+            [
+                rustType('Object'),
+                rustType('Ref'),
+                rustType('Vmt'),
+            ],
+            rustStruct(mapVirtualFn(e))('Interface'),
+            rustImpl({
+                trait: 'nanocom::Interface',
+                type: 'Interface',
+                content: [`const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`]
+            }),
+            trait({ pub: true, type: 'Ex', content: mapTraitFn(e) }),
+            rustImpl({
+                trait: 'Ex',
+                type: 'Object',
+                content: flatMapImplFn(e)
+            }),
+            traitImpl({
+                pub: true,
+                type: 'ClassEx',
+                content: ['const VMT: Vmt = Vmt {',
+                    ['iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
+                        'interface: Interface {',
+                        mapAssign(e),
+                        '},',
+                    ],
+                    '};'
+                ]
+            }),
+            traitImpl({
+                type: 'PrivateClassEx',
+                content: flatMapImpl(e)
+            }),
+            '}'
+        ];
+    };
+    /** @type {(type: O.Entry<types.Definition>) => Text.Block} */
+    const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name);
+    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))]);
+};

package/out/com/rust/test.f.mjs

@@ -0,0 +1,123 @@
+import rust from './testlib.f.mjs';
+export default () => {
+    const e = '#![allow(non_snake_case)]\n' +
+        '#[repr(C)]\n' +
+        'pub struct Slice {\n' +
+        '    pub Start: *const u8,\n' +
+        '    pub Size: usize,\n' +
+        '}\n' +
+        '#[repr(C)]\n' +
+        'pub struct ManagedStruct {\n' +
+        '    pub M: IMy::Ref,\n' +
+        '}\n' +
+        'pub mod IMy {\n' +
+        '    pub type Object = nanocom::Object<Interface>;\n' +
+        '    pub type Ref = nanocom::Ref<Interface>;\n' +
+        '    pub type Vmt = nanocom::Vmt<Interface>;\n' +
+        '    #[repr(C)]\n' +
+        '    pub struct Interface {\n' +
+        '        pub GetSlice: unsafe extern "system" fn(this: &Object) -> super::Slice,\n' +
+        '        pub SetSlice: unsafe extern "system" fn(this: &Object, slice: super::Slice),\n' +
+        '        pub GetUnsafe: unsafe extern "system" fn(this: &Object) -> *const bool,\n' +
+        '        pub SetUnsafe: unsafe extern "system" fn(this: &Object, p: *const super::Slice, size: u32),\n' +
+        '        pub Some: unsafe extern "system" fn(this: &Object, p: &super::IMy::Object) -> bool,\n' +
+        '        pub GetIMy: unsafe extern "system" fn(this: &Object, a: u16, b: i16) -> super::IMy::Ref,\n' +
+        '        pub SetManagedStruct: unsafe extern "system" fn(this: &Object, a: super::ManagedStruct),\n' +
+        '    }\n' +
+        '    impl nanocom::Interface for Interface {\n' +
+        '        const GUID: nanocom::GUID = 0xC66FB270_2D80_49AD_BB6E_88C1F90B805D;\n' +
+        '    }\n' +
+        '    pub trait Ex {\n' +
+        '        fn GetSlice(&self) -> super::Slice;\n' +
+        '        fn SetSlice(&self, slice: super::Slice);\n' +
+        '        fn GetUnsafe(&self) -> *const bool;\n' +
+        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32);\n' +
+        '        fn Some(&self, p: &super::IMy::Object) -> bool;\n' +
+        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref;\n' +
+        '        fn SetManagedStruct(&self, a: super::ManagedStruct);\n' +
+        '    }\n' +
+        '    impl Ex for Object {\n' +
+        '        fn GetSlice(&self) -> super::Slice {\n' +
+        '            unsafe { (self.interface().GetSlice)(self) }\n' +
+        '        }\n' +
+        '        fn SetSlice(&self, slice: super::Slice) {\n' +
+        '            unsafe { (self.interface().SetSlice)(self, slice) }\n' +
+        '        }\n' +
+        '        fn GetUnsafe(&self) -> *const bool {\n' +
+        '            unsafe { (self.interface().GetUnsafe)(self) }\n' +
+        '        }\n' +
+        '        fn SetUnsafe(&self, p: *const super::Slice, size: u32) {\n' +
+        '            unsafe { (self.interface().SetUnsafe)(self, p, size) }\n' +
+        '        }\n' +
+        '        fn Some(&self, p: &super::IMy::Object) -> bool {\n' +
+        '            unsafe { (self.interface().Some)(self, p) }\n' +
+        '        }\n' +
+        '        fn GetIMy(&self, a: u16, b: i16) -> super::IMy::Ref {\n' +
+        '            unsafe { (self.interface().GetIMy)(self, a, b) }\n' +
+        '        }\n' +
+        '        fn SetManagedStruct(&self, a: super::ManagedStruct) {\n' +
+        '            unsafe { (self.interface().SetManagedStruct)(self, a) }\n' +
+        '        }\n' +
+        '    }\n' +
+        '    pub trait ClassEx\n' +
+        '    where\n' +
+        '        Self: nanocom::Class<Interface = Interface>,\n' +
+        '        nanocom::CObject<Self>: Ex,\n' +
+        '    {\n' +
+        '        const VMT: Vmt = Vmt {\n' +
+        '            iunknown: nanocom::CObject::<Self>::IUNKNOWN,\n' +
+        '            interface: Interface {\n' +
+        '                GetSlice: Self::GetSlice,\n' +
+        '                SetSlice: Self::SetSlice,\n' +
+        '                GetUnsafe: Self::GetUnsafe,\n' +
+        '                SetUnsafe: Self::SetUnsafe,\n' +
+        '                Some: Self::Some,\n' +
+        '                GetIMy: Self::GetIMy,\n' +
+        '                SetManagedStruct: Self::SetManagedStruct,\n' +
+        '            },\n' +
+        '        };\n' +
+        '    }\n' +
+        '    impl<T> ClassEx for T\n' +
+        '    where\n' +
+        '        Self: nanocom::Class<Interface = Interface>,\n' +
+        '        nanocom::CObject<Self>: Ex,\n' +
+        '    {\n' +
+        '    }\n' +
+        '    trait PrivateClassEx\n' +
+        '    where\n' +
+        '        Self: nanocom::Class<Interface = Interface>,\n' +
+        '        nanocom::CObject<Self>: Ex,\n' +
+        '    {\n' +
+        '        extern "system" fn GetSlice(this: &Object) -> super::Slice {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetSlice()\n' +
+        '        }\n' +
+        '        extern "system" fn SetSlice(this: &Object, slice: super::Slice) {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetSlice(slice)\n' +
+        '        }\n' +
+        '        extern "system" fn GetUnsafe(this: &Object) -> *const bool {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetUnsafe()\n' +
+        '        }\n' +
+        '        extern "system" fn SetUnsafe(this: &Object, p: *const super::Slice, size: u32) {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetUnsafe(p, size)\n' +
+        '        }\n' +
+        '        extern "system" fn Some(this: &Object, p: &super::IMy::Object) -> bool {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.Some(p)\n' +
+        '        }\n' +
+        '        extern "system" fn GetIMy(this: &Object, a: u16, b: i16) -> super::IMy::Ref {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetIMy(a, b)\n' +
+        '        }\n' +
+        '        extern "system" fn SetManagedStruct(this: &Object, a: super::ManagedStruct) {\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetManagedStruct(a)\n' +
+        '        }\n' +
+        '    }\n' +
+        '    impl<T> PrivateClassEx for T\n' +
+        '    where\n' +
+        '        Self: nanocom::Class<Interface = Interface>,\n' +
+        '        nanocom::CObject<Self>: Ex,\n' +
+        '    {\n' +
+        '    }\n' +
+        '}';
+    if (rust !== e) {
+        throw rust;
+    }
+};

package/out/com/rust/testlib.f.mjs

@@ -0,0 +1,7 @@
+import * as text from '../../text/module.f.mjs';
+const { flat } = text;
+import * as string from '../../types/string/module.f.mjs';
+const { join } = string;
+import { rust } from './module.f.mjs';
+import library from '../types/testlib.f.mjs';
+export default join('\n')(flat('    ')(rust(library)));

package/out/com/test/build.f.mjs

@@ -0,0 +1,98 @@
+import * as list from '../../types/list/module.f.mjs';
+const { flat } = list;
+import cppContent from '../cpp/testlib.f.mjs';
+import csContent from '../cs/testlib.f.mjs';
+import rustContent from '../rust/testlib.f.mjs';
+/**
+ * @typedef {|
+ *  'aix' |
+ *  'android' |
+ *  'darwin' |
+ *  'freebsd' |
+ *  'haiku' |
+ *  'linux' |
+ *  'openbsd' |
+ *  'sunos' |
+ *  'win32' |
+ *  'cygwin' |
+ *  'netbsd'
+ * } Platform
+ */
+/**
+ * @typedef {{
+ *  readonly dirname: string
+ *  readonly platform: Platform
+ * }} NodeJs
+ */
+/**
+ * @typedef {{
+ *  readonly file: {
+ *      readonly name: string
+ *      readonly content: string
+ *  }
+ *  readonly line: list.List<list.List<string>>
+ * }} Output
+ */
+/** @typedef {(nodejs: NodeJs) => Output} Func */
+/** @type {(platform: Platform) => readonly string[]} */
+const flags = platform => {
+    switch (platform) {
+        case 'win32':
+            return [];
+        case 'linux':
+            return ['-std=c++17', '-lstdc++', '-fPIC'];
+        default:
+            return ['-std=c++17', '-lc++'];
+    }
+};
+/** @type {(platform: Platform) => (name: string) => string} */
+const output = platform => name => {
+    switch (platform) {
+        case 'win32': return `${name}.dll`;
+        case 'darwin': return `lib${name}.dylib`;
+        default: return `lib${name}.so`;
+    }
+};
+/** @type {Func} */
+const cpp = ({ dirname, platform }) => ({
+    file: {
+        name: `${dirname}/cpp/_result.hpp`,
+        content: cppContent(),
+    },
+    line: [
+        flat([
+            ['clang', '-shared', '-o', output(platform)('testc')],
+            flags(platform),
+            [`${dirname}/cpp/main.cpp`],
+        ]),
+    ],
+});
+/** @type {Func} */
+const cs = ({ dirname, platform }) => ({
+    file: {
+        name: `${dirname}/cs/_result.cs`,
+        content: csContent,
+    },
+    line: [
+        platform === 'win32'
+            ? ['dotnet', 'run', '--project', `${dirname}/cs/cs.csproj`]
+            // .Net on Linux and MacOS doesn't properly support COM object marshalling
+            : ['dotnet', 'build', `${dirname}/cs/cs.csproj`]
+    ],
+});
+/** @type {Func} */
+const rust = ({ dirname }) => ({
+    file: {
+        name: `${dirname}/rust/src/_result.rs`,
+        content: rustContent,
+    },
+    line: [['cargo', 'build' /**, '--locked' */]]
+});
+export default {
+    /** @readonly */
+    cpp,
+    /** @readonly */
+    cs,
+    /** @readonly */
+    rust,
+};

package/out/com/test/build.mjs

@@ -0,0 +1,40 @@
+import { writeFileSync } from 'node:fs';
+import { execSync } from 'node:child_process';
+import { platform, exit } from 'node:process';
+import build, * as Build from './build.f.mjs';
+const { cpp, cs, rust } = build;
+import * as string from '../../types/string/module.f.mjs';
+const { join } = string;
+const { log, error } = console;
+import * as sgr from '../../text/sgr/module.f.mjs';
+const { bold, reset } = sgr.codes;
+import * as list from '../../types/list/module.f.mjs';
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const nodeJs = {
+    dirname: __dirname,
+    platform,
+};
+/** @type {(f: Build.Func) => void} */
+const run = f => {
+    const { file: { name, content }, line } = f(nodeJs);
+    log(`${bold}writing: ${name}${reset}`);
+    writeFileSync(name, content);
+    for (const i of list.iterable(line)) {
+        const cmd = join(' ')(i);
+        log(`${bold}running: ${cmd}${reset}`);
+        try {
+            log(execSync(cmd).toString());
+        }
+        catch (e) {
+            // @ts-ignore
+            error(e.output.toString());
+            exit(-1);
+        }
+    }
+};
+run(cpp);
+run(rust);
+run(cs);

package/out/com/types/module.f.mjs

@@ -0,0 +1,51 @@
+// @ts-self-types="./module.f.d.mts"
+import * as O from '../../types/object/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';
+import * as f from '../../types/function/module.f.mjs';
+const { compose } = f;
+const { filter } = list;
+const { entries } = Object;
+/** @typedef {{readonly[k in string]: Definition}} Library */
+/** @typedef {Struct|Interface} Definition */
+/**
+ * @typedef {{
+ *  readonly struct: FieldArray
+ * }} Struct
+ */
+/** @typedef {{readonly[k in string]: Type}} FieldArray */
+/** @typedef {O.Entry<Type>} Field */
+/**
+ * @typedef {{
+ *  readonly interface: MethodArray
+ *  readonly guid: string
+ * }} Interface
+ */
+/** @typedef {{readonly[k in string]: FieldArray}} MethodArray */
+/** @typedef {O.Entry<FieldArray>} Method */
+/** @typedef {BaseType|Id|Pointer} Type */
+/** @typedef {readonly[string]} Id */
+/**
+ * @typedef {|
+ *  'u8'|
+ *  'i8'|
+ *  'u16'|
+ *  'i16'|
+ *  'u32'|
+ *  'i32'|
+ *  'u64'|
+ *  'i64'|
+ *  'usize'|
+ *  'isize'|
+ *  'f32'|
+ *  'f64'|
+ *  'bool'
+ * } BaseType
+ */
+/** @typedef {readonly['*', Type]} Pointer */
+/** @type {(kv: O.Entry<Type>) => boolean} */
+const isParam = ([name]) => name !== '_';
+const filterParam = filter(isParam);
+/** @type {(fa: FieldArray) => list.List<Field> } */
+export const paramList = compose(entries)(filterParam);
+/** @type {<T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T} */
+export const result = v => f => fa => '_' in fa ? f(fa._) : v;

package/out/com/types/testlib.f.mjs

@@ -0,0 +1,30 @@
+import * as _ from './module.f.mjs';
+/** @type {_.Library} */
+export default {
+    Slice: {
+        struct: {
+            Start: ['*', 'u8'],
+            Size: 'usize',
+        },
+    },
+    ManagedStruct: {
+        struct: {
+            M: ['IMy']
+        }
+    },
+    IMy: {
+        guid: 'C66FB270-2D80-49AD-BB6E-88C1F90B805D',
+        interface: {
+            GetSlice: { _: ['Slice'] },
+            SetSlice: { slice: ['Slice'] },
+            GetUnsafe: { _: ['*', 'bool'] },
+            SetUnsafe: {
+                p: ['*', ['Slice']],
+                size: 'u32'
+            },
+            Some: { p: ['IMy'], _: 'bool' },
+            GetIMy: { a: 'u16', b: 'i16', _: ['IMy'] },
+            SetManagedStruct: { a: ['ManagedStruct'] },
+        },
+    }
+};

package/out/commonjs/build/module.f.mjs

@@ -0,0 +1,107 @@
+// @ts-self-types="./module.f.d.mts"
+import * as package_ from '../package/module.f.mjs';
+import * as module from '../module/module.f.mjs';
+const { idToString, dir } = module;
+import * as function_ from '../module/function/module.f.mjs';
+import * as map from '../../types/map/module.f.mjs';
+const { empty: mapEmpty, setReplace } = map;
+import * as object from '../../types/object/module.f.mjs';
+const { fromMap } = object;
+import * as path from '../path/module.f.mjs';
+const { parseAndFind } = path;
+import * as stringSet from '../../types/string_set/module.f.mjs';
+const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet;
+/**
+ * @template M
+ * @typedef {{
+ *  readonly packageGet: package_.Get
+ *  readonly moduleMapInterface: module.MapInterface<M>
+ *  readonly moduleId: module.Id
+ *  readonly moduleMap: M
+ * }} Config
+ */
+/**
+ * @template M
+ * @typedef {readonly[module.State, M]} Result
+ */
+/** @type {<M>(moduleMap: M) => Result<M>} */
+const notFound = moduleMap => [['error', ['file not found']], moduleMap];
+/**
+ * @type {(compile: function_.Compile) =>
+ *  (packageGet: package_.Get) =>
+ *  <M>(moduleMapInterface: module.MapInterface<M>) =>
+ *  (moduleId: module.Id) =>
+ *  (moduleMap: M) =>
+ *  Result<M>
+ * }
+ */
+export const getOrBuild = compile => packageGet => moduleMapInterface => {
+    /** @typedef {typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never} M */
+    /**
+     * @type {(buildSet: stringSet.StringSet) =>
+     *  (moduleId: module.Id) =>
+     *  (source: string) =>
+     *  (moduleMap: M) =>
+     *  Result<M>}
+     */
+    const build = buildSet => moduleId => {
+        const moduleIdStr = idToString(moduleId);
+        const buildSet1 = setSet(moduleIdStr)(buildSet);
+        const moduleDir = dir(moduleId);
+        /** @type {function_.Require<readonly[map.Map<string>, M]>} */
+        const require_ = p => ([requireMap, m]) => {
+            /** @type {(e: unknown) => function_.Result<readonly[map.Map<string>, M]>} */
+            const error = e => [['error', e], [requireMap, m]];
+            if (moduleDir === null) {
+                return error('file not found');
+            }
+            const r = parseAndFind(packageGet)(moduleDir)(p);
+            if (r === null) {
+                return error('file not found');
+            }
+            const rIdStr = idToString(r.id);
+            if (setContains(rIdStr)(buildSet1)) {
+                return error('circular reference');
+            }
+            const [state, m1] = build(buildSet1)(r.id)(r.source)(m);
+            return [state[0] === 'error' ? state : ['ok', state[1].exports], [setReplace(p)(rIdStr)(requireMap), m1]];
+        };
+        return source => moduleMap => {
+            /** @type {(s: module.State) => (m: M) => Result<M>} */
+            const set = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)];
+            /** @type {(e: module.Error) => (m: M) => Result<M>} */
+            const error = e => set(['error', e]);
+            // check compilation
+            const [kind, result] = compile(source);
+            if (kind === 'error') {
+                return error(['compilation error', result])(moduleMap);
+            }
+            // build
+            const [[state, value], [requireMap, moduleMap2]] = result(require_)([mapEmpty, moduleMap]);
+            const x = state === 'error' ?
+                error(['runtime error', value]) :
+                set(['ok', { exports: value, requireMap: fromMap(requireMap) }]);
+            return x(moduleMap2);
+        };
+    };
+    /** @type {(moduleId: module.Id) => (moduleMap: M) => Result<M>} */
+    const f = moduleId => moduleMap => {
+        const moduleIdStr = idToString(moduleId);
+        // check moduleMap
+        {
+            const m = moduleMapInterface.at(moduleIdStr)(moduleMap);
+            if (m !== null) {
+                return [m, moduleMap];
+            }
+        }
+        // check package
+        const p = packageGet(moduleId.package);
+        if (p === null) {
+            return notFound(moduleMap);
+        }
+        // check file
+        const source = p.file(moduleId.path.join('/'));
+        return (source === null ? notFound : build(stringSetEmpty)(moduleId)(source))(moduleMap);
+    };
+    return f;
+};