functionalscript 0.3.4 → 0.3.6

package/com/cpp/module.f.d.ts

@@ -0,0 +1,10 @@
+/**
+ * This module generates C++ code blocks, including structs, interfaces, and method headers,
+ * based on a COM library of type definitions.
+ */
+import { type Library } from '../types/module.f.ts';
+import * as text from '../../text/module.f.ts';
+/**
+ * Generates the C++ code for a library.
+ */
+export declare const cpp: (name: string) => (lib: Library) => text.Block;

package/com/cpp/module.f.js

@@ -0,0 +1,107 @@
+/**
+ * This module generates C++ code blocks, including structs, interfaces, and method headers,
+ * based on a COM library of type definitions.
+ */
+import { paramList, result, } from "../types/module.f.js";
+import * as text from "../../text/module.f.js";
+import * as O from "../../types/object/module.f.js";
+import { map, flatMap, flat } from "../../types/list/module.f.js";
+import { join } from "../../types/string/module.f.js";
+const { entries } = Object;
+const struct = (name) => (body) => [`struct ${name}`, '{', body, '};'];
+const baseTypeMap = {
+    u8: 'uint8_t',
+    i8: 'int8_t',
+    u16: 'uint16_t',
+    i16: 'int16_t',
+    u32: 'uint32_t',
+    i32: 'int32_t',
+    u64: 'uint64_t',
+    i64: 'int64_t',
+    usize: 'size_t',
+    isize: 'ptrdiff_t',
+    f32: 'float',
+    f64: 'double',
+    bool: 'bool',
+};
+const baseType = (t) => baseTypeMap[t];
+const resultVoid = result('void');
+const namespace = text.curly('namespace');
+const comRef = (id) => `::nanocom::ref<${id}>`;
+const ptr = (id) => `${id} const*`;
+const ref = (id) => `${id} const&`;
+const paramName = ([name]) => name;
+const mapParamName = map(paramName);
+const joinComma = join(', ');
+/**
+ * Generates the C++ code for a library.
+ */
+export const cpp = (name) => (lib) => {
+    const interface_ = (t) => {
+        if (!(t instanceof Array) || t.length !== 1) {
+            return null;
+        }
+        const [name] = t;
+        return 'interface' in lib[name] ? name : null;
+    };
+    const objectType = (i) => (t) => {
+        if (typeof (t) === 'string') {
+            return baseType(t);
+        }
+        if (t.length === 2) {
+            return `${type(t[1])} const*`;
+        }
+        const [id] = t;
+        return 'interface' in lib[id] ? i(id) : id;
+    };
+    const type = objectType(comRef);
+    const resultType = objectType(ptr);
+    const field = ([name, t]) => `${type(t)} ${name};`;
+    const mapField = map(field);
+    const defStruct = (s) => mapField(entries(s.struct));
+    const cppResult = resultVoid(resultType);
+    const param = ([name, t]) => `${objectType(ref)(t)} ${name}`;
+    const mapParam = map(param);
+    const methodHeader = (result) => (paramArrayStr) => (name) => `virtual ${result} ${name}${paramArrayStr} const noexcept = 0;`;
+    const method = ([name, paramArray]) => {
+        const result = cppResult(paramArray);
+        const paramL = paramList(paramArray);
+        const paramArrayStr = `(${joinComma(mapParam(paramL))})`;
+        const m = methodHeader(result)(paramArrayStr);
+        const resultName = interface_(paramArray._);
+        if (resultName === null) {
+            return [m(name)];
+        }
+        return [
+            m(`${name}_`),
+            `${comRef(resultName)} ${name}${paramArrayStr} const noexcept`,
+            '{',
+            [`return ::nanocom::move_to_ref(${name}_(${joinComma(mapParamName(paramL))}));`],
+            '}',
+        ];
+    };
+    const mapMethod = flatMap(method);
+    const defInterface = ({ guid, interface: i }) => {
+        const g = guid.replaceAll('-', '');
+        const lo = g.substring(0, 16);
+        const hi = g.substring(16);
+        return flat([
+            [`constexpr static ::nanocom::GUID const guid = ::nanocom::GUID(0x${lo}, 0x${hi});`],
+            mapMethod(entries(i))
+        ]);
+    };
+    const def = ([name, d]) => 'interface' in d ?
+        [`class ${name} : public ::nanocom::IUnknown`,
+            '{',
+            'public:',
+            defInterface(d),
+            '};'
+        ] :
+        struct(name)(defStruct(d));
+    const forward = ([name]) => [`struct ${name};`];
+    const e = entries(lib);
+    return flat([
+        ['#pragma once', ''],
+        namespace(name)(flat([flatMap(forward)(e), flatMap(def)(e)]))
+    ]);
+};

package/com/cpp/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const f: () => void;
+export default f;

package/com/cpp/{test.f.ts → test.f.js}

@@ -1,9 +1,6 @@
-import cpp from './testlib.f.ts'
-
-const f = () =>
-{
-    const e =
-        '#pragma once\n' +
+import cpp from "./testlib.f.js";
+const f = () => {
+    const e = '#pragma once\n' +
         '\n' +
         'namespace My\n' +
         '{\n' +
@@ -35,8 +32,9 @@ const f = () =>
         '        }\n' +
         '        virtual void SetManagedStruct(ManagedStruct a) const noexcept = 0;\n' +
         '    };\n' +
-        '}'
-    if (cpp() !== e) { throw cpp }
-}
-
-export default f
+        '}';
+    if (cpp() !== e) {
+        throw cpp;
+    }
+};
+export default f;

package/com/cpp/testlib.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => string;
+export default _default;

package/com/cpp/testlib.f.js

@@ -0,0 +1,5 @@
+import { join } from "../../types/string/module.f.js";
+import { flat } from "../../text/module.f.js";
+import library from "../types/testlib.f.js";
+import { cpp } from "./module.f.js";
+export default () => join('\n')(flat('    ')(cpp('My')(library)));

package/com/cs/module.f.d.ts

@@ -0,0 +1,12 @@
+/**
+ * This module generates C# code blocks for COM interop from a high-level type library definition.
+ *
+ * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
+ * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
+ */
+import { type Library } from '../types/module.f.ts';
+import { type Block } from '../../text/module.f.ts';
+/**
+ * Generates the C# code for a library.
+ */
+export declare const cs: (name: string) => (library: Library) => Block;

package/com/cs/module.f.js

@@ -0,0 +1,80 @@
+/**
+ * This module generates C# code blocks for COM interop from a high-level type library definition.
+ *
+ * The module maps type definitions (e.g., structs, interfaces, and methods) into C# constructs
+ * with appropriate attributes for COM interop, such as `[StructLayout]`, `[Guid]`, and `[InterfaceType]`.
+ */
+import { result, paramList, } from "../types/module.f.js";
+import { curly } from "../../text/module.f.js";
+import { flat, map, some, flatMap } from "../../types/list/module.f.js";
+import { join } from "../../types/string/module.f.js";
+import * as O from "../../types/object/module.f.js";
+const { entries } = Object;
+const using = (v) => `using ${v};`;
+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',
+};
+const baseType = (t) => baseTypeMap[t];
+const unsafe = isUnsafe => isUnsafe ? 'unsafe ' : '';
+const fullType = t => typeof (t) === 'string' ?
+    [false, baseType(t)] :
+    t.length === 1 ?
+        [false, t[0]] :
+        [true, `${type(t[1])}*`];
+const type = t => fullType(t)[1];
+const param = ([name, t]) => `${type(t)} ${name}`;
+const mapParam = map(param);
+const field = ([name, comType]) => {
+    const [isUnsafe, t] = fullType(comType);
+    return `public ${unsafe(isUnsafe)}${t} ${name};`;
+};
+const isUnsafeField = field => fullType(field[1])[0];
+const mapIsUnsafeField = map(isUnsafeField);
+const resultVoid = result('void');
+const joinComma = join(', ');
+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);
+const def = ([n, d]) => !('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');
+const header = [
+    using('System'),
+    using('System.Runtime.InteropServices'),
+    ''
+];
+/**
+ * Generates the C# code for a library.
+ */
+export const cs = name => library => {
+    const v = flatMapDef(entries(library));
+    const ns = namespace(name)(v);
+    return flat([header, ns]);
+};

package/com/cs/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const f: () => void;
+export default f;

package/com/cs/{test.f.ts → test.f.js}

@@ -1,9 +1,6 @@
-import cs from './testlib.f.ts'
-
-const f = () =>
-{
-    const e =
-        'using System;\n' +
+import cs from "./testlib.f.js";
+const f = () => {
+    const e = 'using System;\n' +
         'using System.Runtime.InteropServices;\n' +
         '\n' +
         'namespace My\n' +
@@ -38,8 +35,9 @@ const f = () =>
         '        [PreserveSig]\n' +
         '        void SetManagedStruct(ManagedStruct a);\n' +
         '    }\n' +
-        '}'
-    if (cs !== e) { throw cs }
-}
-
-export default f
+        '}';
+    if (cs !== e) {
+        throw cs;
+    }
+};
+export default f;

package/com/cs/testlib.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/com/cs/testlib.f.js

@@ -0,0 +1,5 @@
+import { flat } from "../../text/module.f.js";
+import { join } from "../../types/string/module.f.js";
+import { cs } from "./module.f.js";
+import library from "../types/testlib.f.js";
+export default join('\n')(flat('    ')(cs('My')(library)));

package/com/rust/module.f.d.ts

@@ -0,0 +1,15 @@
+/**
+ * This module generates Rust code for COM interop from a high-level type library definition.
+ *
+ * The module provides functions to define structs, traits, and implementations in Rust,
+ * specifically tailored for `nanocom` interoperation.
+ */
+import { type Library } from '../types/module.f.ts';
+import * as Text from '../../text/module.f.ts';
+/**
+ * Generates Rust code for the given type library.
+ *
+ * @param library - The library of type definitions to generate Rust code for.
+ * @returns A block of Rust code representing the library.
+ */
+export declare const rust: (library: Library) => Text.Block;

package/com/rust/module.f.js

@@ -0,0 +1,169 @@
+/**
+ * This module generates Rust code for COM interop from a high-level type library definition.
+ *
+ * The module provides functions to define structs, traits, and implementations in Rust,
+ * specifically tailored for `nanocom` interoperation.
+ */
+import { paramList } from "../types/module.f.js";
+import * as Text from "../../text/module.f.js";
+import * as O from "../../types/object/module.f.js";
+import * as list from "../../types/list/module.f.js";
+const { flat, map, flatMap } = list;
+const { entries } = Object;
+import * as func from "../../types/function/module.f.js";
+const { fn } = func;
+import * as string from "../../types/string/module.f.js";
+const { join } = string;
+const rustField = field => `pub ${field},`;
+const mapRustField = map(rustField);
+const rustStruct = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`];
+const commaJoin = join(', ');
+const ref = name => `${name}::Ref`;
+const obj = name => `&${name}::Object`;
+const self = ['&self'];
+const paramName = ([n]) => n;
+const callList = p => map(paramName)(paramList(p));
+const call = p => commaJoin(callList(p));
+const virtualCall = p => commaJoin(flat([['self'], callList(p)]));
+const super_ = 'super::';
+const assign = ([n]) => `${n}: Self::${n},`;
+const mapAssign = map(assign);
+const this_ = ['this: &Object'];
+const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`;
+const whereContent = h => wh => {
+    const w = 'where' in wh ? [
+        h,
+        `where`,
+        mapComma(wh.where),
+        '{'
+    ] : [`${h} {`];
+    const x = [
+        wh.content,
+        '}',
+    ];
+    return flat([w, x]);
+};
+const rustImpl = i => {
+    const p = 'param' in i ? `<${i.param}>` : '';
+    const header = `impl${p} ${i.trait} for ${i.type}`;
+    return whereContent(header)(i);
+};
+const comma = s => `${s},`;
+const mapComma = map(comma);
+const trait = t => {
+    const p = t.pub === true ? 'pub ' : '';
+    const h = `${p}trait ${t.type}`;
+    return whereContent(h)(t);
+};
+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'];
+/**
+ * Generates Rust code for the given type library.
+ *
+ * @param library - The library of type definitions to generate Rust code for.
+ * @returns A block of Rust code representing the library.
+ */
+export const rust = (library) => {
+    const type = p => {
+        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;
+    };
+    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));
+    const struct = fn(entries)
+        .then(mapField)
+        .then(rustStruct)
+        .result;
+    const func = first => p => {
+        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : '';
+        const params = commaJoin(flat([first, mapParam(paramList(p))]));
+        return `(${params})${resultStr}`;
+    };
+    const virtualFnType = n => p => `extern "system" fn${n}${func(this_)(p)}`;
+    const virtualFn = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`;
+    const mapVirtualFn = map(virtualFn);
+    const headerFn = ([n, p]) => `fn ${n}${func(self)(p)}`;
+    const traitFn = m => `${headerFn(m)};`;
+    const mapTraitFn = map(traitFn);
+    const implFn = m => {
+        const [n, p] = m;
+        return [
+            `${headerFn(m)} {`,
+            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
+            '}'
+        ];
+    };
+    const flatMapImplFn = flatMap(implFn);
+    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);
+    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)
+            }),
+            '}'
+        ];
+    };
+    const def = ([name, type]) => ('interface' in type ? interface_(type) : struct(type.struct))(name);
+    return flat([['#![allow(non_snake_case)]'], flatMap(def)(entries(library))]);
+};

package/com/rust/test.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => void;
+export default _default;

package/com/rust/{test.f.ts → test.f.js}

@@ -1,8 +1,6 @@
-import rust from './testlib.f.ts'
-
+import rust from "./testlib.f.js";
 export default () => {
-    const e =
-        '#![allow(non_snake_case)]\n' +
+    const e = '#![allow(non_snake_case)]\n' +
         '#[repr(C)]\n' +
         'pub struct Slice {\n' +
         '    pub Start: *const u8,\n' +
@@ -118,6 +116,8 @@ export default () => {
         '        nanocom::CObject<Self>: Ex,\n' +
         '    {\n' +
         '    }\n' +
-        '}'
-    if (rust !== e) { throw rust }
-}
+        '}';
+    if (rust !== e) {
+        throw rust;
+    }
+};

package/com/rust/testlib.f.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string;
+export default _default;

package/com/rust/testlib.f.js

@@ -0,0 +1,5 @@
+import { flat } from "../../text/module.f.js";
+import { join } from "../../types/string/module.f.js";
+import { rust } from "./module.f.js";
+import library from "../types/testlib.f.js";
+export default join('\n')(flat('    ')(rust(library)));

package/com/test/build.f.d.ts

@@ -0,0 +1,20 @@
+import { type List } from '../../types/list/module.f.ts';
+type Platform = 'aix' | 'android' | 'darwin' | 'freebsd' | 'haiku' | 'linux' | 'openbsd' | 'sunos' | 'win32' | 'cygwin' | 'netbsd';
+type NodeJs = {
+    readonly dirname: string;
+    readonly platform: Platform;
+};
+type Output = {
+    readonly file: {
+        readonly name: string;
+        readonly content: string;
+    };
+    readonly line: List<List<string>>;
+};
+export type Func = (nodejs: NodeJs) => Output;
+declare const _default: {
+    cpp: Func;
+    cs: Func;
+    rust: Func;
+};
+export default _default;

package/com/test/build.f.js

@@ -0,0 +1,58 @@
+import { flat } from "../../types/list/module.f.js";
+import cppContent from "../cpp/testlib.f.js";
+import csContent from "../cs/testlib.f.js";
+import rustContent from "../rust/testlib.f.js";
+const flags = platform => {
+    switch (platform) {
+        case 'win32':
+            return [];
+        case 'linux':
+            return ['-std=c++17', '-lstdc++', '-fPIC'];
+        default:
+            return ['-std=c++17', '-lc++'];
+    }
+};
+const output = platform => name => {
+    switch (platform) {
+        case 'win32': return `${name}.dll`;
+        case 'darwin': return `lib${name}.dylib`;
+        default: return `lib${name}.so`;
+    }
+};
+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`],
+        ]),
+    ],
+});
+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`]
+    ],
+});
+const rust = ({ dirname }) => ({
+    file: {
+        name: `${dirname}/rust/src/_result.rs`,
+        content: rustContent,
+    },
+    line: [['cargo', 'build' /**, '--locked' */]]
+});
+export default {
+    cpp,
+    cs,
+    rust,
+};

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

@@ -0,0 +1,28 @@
+import * as O from '../../types/object/module.f.ts';
+import { type List } from '../../types/list/module.f.ts';
+export type Library = {
+    readonly [k in string]: Definition;
+};
+export type Definition = Struct | Interface;
+export type Struct = {
+    readonly struct: FieldArray;
+};
+export type FieldArray = {
+    readonly [k in string]: Type;
+};
+export type Field = O.Entry<Type>;
+export type Interface = {
+    readonly interface: MethodArray;
+    readonly guid: string;
+};
+type MethodArray = {
+    readonly [k in string]: FieldArray;
+};
+export type Method = O.Entry<FieldArray>;
+export type Type = BaseType | Id | Pointer;
+type Id = readonly [string];
+export type BaseType = 'u8' | 'i8' | 'u16' | 'i16' | 'u32' | 'i32' | 'u64' | 'i64' | 'usize' | 'isize' | 'f32' | 'f64' | 'bool';
+type Pointer = readonly ['*', Type];
+export declare const paramList: (fa: FieldArray) => List<Field>;
+export declare const result: <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T;
+export {};

package/com/types/module.f.js

@@ -0,0 +1,8 @@
+import * as O from "../../types/object/module.f.js";
+import { filter } from "../../types/list/module.f.js";
+import { compose } from "../../types/function/module.f.js";
+const { entries } = Object;
+const isParam = ([name]) => name !== '_';
+const filterParam = filter(isParam);
+export const paramList = compose(entries)(filterParam);
+export const result = v => f => fa => '_' in fa ? f(fa._) : v;