functionalscript 0.1.609 → 0.2.1

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

@@ -0,0 +1,95 @@
+// @ts-self-types="./module.f.d.mts"
+import * as types from '../types/module.f.mjs';
+const { result, paramList } = types;
+import * as text from '../../text/module.f.mjs';
+const { curly } = text;
+import * as list from '../../types/list/module.f.mjs';
+const { flat, map, some, flatMap } = list;
+import * as string from '../../types/string/module.f.mjs';
+const { join } = string;
+import * as O from '../../types/object/module.f.mjs';
+const { entries } = Object;
+/** @type {(v: string) => string} */
+const using = v => `using ${v};`;
+/**
+ * @type {(attributes: list.List<string>) =>
+ *  (type: string) =>
+ *  (name: string) =>
+ *  (body: text.Block) =>
+ *  list.List<text.Item>}
+ */
+const typeDef = attributes => type => name => body => flat([
+    map(v => `[${v}]`)(attributes),
+    curly(`public ${type}`)(name)(body)
+]);
+const baseTypeMap = {
+    bool: 'byte',
+    f32: 'float',
+    f64: 'double',
+    i16: 'short',
+    i32: 'int',
+    i64: 'long',
+    i8: 'sbyte',
+    isize: 'IntPtr',
+    u16: 'ushort',
+    u32: 'uint',
+    u64: 'ulong',
+    u8: 'byte',
+    usize: 'UIntPtr',
+};
+/** @type {(t: types.BaseType) => string} */
+const baseType = t => baseTypeMap[t];
+/** @type {(isUnsafe: boolean) => string} */
+const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : '';
+/** @type {(t: types.Type) => readonly[boolean, string]} */
+const fullType = t => typeof (t) === 'string' ? [false, baseType(t)] :
+    t.length === 1 ? [false, t[0]] :
+        [true, `${type(t[1])}*`];
+/** @type {(m: types.Type) => string} */
+const type = t => fullType(t)[1];
+/** @type {(f: types.Field) => string} */
+const param = ([name, t]) => `${type(t)} ${name}`;
+const mapParam = map(param);
+/** @type {(f: types.Field) => string} */
+const field = ([name, comType]) => {
+    const [isUnsafe, t] = fullType(comType);
+    return `public ${unsafe(isUnsafe)}${t} ${name};`;
+};
+/** @type {(field: types.Field) => boolean} */
+const isUnsafeField = field => fullType(field[1])[0];
+const mapIsUnsafeField = map(isUnsafeField);
+const resultVoid = result('void');
+const joinComma = join(', ');
+/** @type {(e: O.Entry<types.FieldArray>) => readonly string[]} */
+const method = ([name, m]) => {
+    const paramAndResultList = entries(m);
+    const pl = paramList(m);
+    const isUnsafe = some(mapIsUnsafeField(paramAndResultList));
+    return [
+        '[PreserveSig]',
+        `${unsafe(isUnsafe)}${resultVoid(type)(m)} ${name}(${joinComma(mapParam(pl))});`
+    ];
+};
+const struct = typeDef(['StructLayout(LayoutKind.Sequential)'])('struct');
+const mapField = map(field);
+const flatMapMethod = flatMap(method);
+/** @type {(e: O.Entry<types.Definition>) => list.List<text.Item>} */
+const def = ([n, d]) => {
+    return !('interface' in d) ?
+        struct(n)(mapField(entries(d.struct))) :
+        typeDef([`Guid("${d.guid}")`, 'InterfaceType(ComInterfaceType.InterfaceIsIUnknown)'])('interface')(n)(flatMapMethod(entries(d.interface)));
+};
+const flatMapDef = flatMap(def);
+const namespace = curly('namespace');
+/** @type {text.Block} */
+const header = [
+    using('System'),
+    using('System.Runtime.InteropServices'),
+    ''
+];
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+export const cs = name => library => {
+    const v = flatMapDef(entries(library));
+    const ns = namespace(name)(v);
+    return flat([header, ns]);
+};

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

@@ -0,0 +1,43 @@
+import cs from './testlib.f.mjs';
+const f = () => {
+    const e = 'using System;\n' +
+        'using System.Runtime.InteropServices;\n' +
+        '\n' +
+        'namespace My\n' +
+        '{\n' +
+        '    [StructLayout(LayoutKind.Sequential)]\n' +
+        '    public struct Slice\n' +
+        '    {\n' +
+        '        public unsafe byte* Start;\n' +
+        '        public UIntPtr Size;\n' +
+        '    }\n' +
+        '    [StructLayout(LayoutKind.Sequential)]\n' +
+        '    public struct ManagedStruct\n' +
+        '    {\n' +
+        '        public IMy M;\n' +
+        '    }\n' +
+        '    [Guid("C66FB270-2D80-49AD-BB6E-88C1F90B805D")]\n' +
+        '    [InterfaceType(ComInterfaceType.InterfaceIsIUnknown)]\n' +
+        '    public interface IMy\n' +
+        '    {\n' +
+        '        [PreserveSig]\n' +
+        '        Slice GetSlice();\n' +
+        '        [PreserveSig]\n' +
+        '        void SetSlice(Slice slice);\n' +
+        '        [PreserveSig]\n' +
+        '        unsafe byte* GetUnsafe();\n' +
+        '        [PreserveSig]\n' +
+        '        unsafe void SetUnsafe(Slice* p, uint size);\n' +
+        '        [PreserveSig]\n' +
+        '        byte Some(IMy p);\n' +
+        '        [PreserveSig]\n' +
+        '        IMy GetIMy(ushort a, short b);\n' +
+        '        [PreserveSig]\n' +
+        '        void SetManagedStruct(ManagedStruct a);\n' +
+        '    }\n' +
+        '}';
+    if (cs !== e) {
+        throw cs;
+    }
+};
+export default f;

package/out/com/cs/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 { cs } from './module.f.mjs';
+import library from '../types/testlib.f.mjs';
+export default join('\n')(flat('    ')(cs('My')(library)));

package/{com → out/com}/rust/module.f.d.mts

@@ -1,7 +1,5 @@
-declare namespace _default {
-    export { rust };
-}
-export default _default;
+/** @type {(library: types.Library) => Text.Block} */
+export const rust: (library: types.Library) => Text.Block;
 export type OptionalProperty<T> = T | {};
 export type Where = {
     readonly where: readonly string[];
@@ -22,7 +20,5 @@ export type Trait = {
     readonly where?: readonly string[];
     readonly content: Text.Block;
 };
-/** @type {(library: Types.Library) => Text.Block} */
-declare const rust: (library: Types.Library) => Text.Block;
+import * as types from '../types/module.f.mjs';
 import * as Text from '../../text/module.f.mjs';
-import * as Types from '../types/module.f.mjs';

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/{com → out/com}/test/build.f.d.mts

@@ -14,7 +14,7 @@ export type Output = {
         readonly name: string;
         readonly content: string;
     };
-    readonly line: List.List<List.List<string>>;
+    readonly line: list.List<list.List<string>>;
 };
 export type Func = (nodejs: NodeJs) => Output;
 /** @type {Func} */
@@ -23,4 +23,4 @@ declare const cpp: Func;
 declare const cs: Func;
 /** @type {Func} */
 declare const rust: Func;
-import * as List from '../../types/list/module.f.mjs';
+import * as list from '../../types/list/module.f.mjs';

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);