functionalscript 0.2.5 → 0.3.0

package/com/rust/module.f.ts

@@ -0,0 +1,287 @@
+/**
+ * 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 * as types from '../types/module.f.ts'
+const { paramList } = types
+import * as Text from '../../text/module.f.ts'
+import * as O from '../../types/object/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
+const { flat, map, flatMap } = list
+const { entries } = Object
+import * as func from '../../types/function/module.f.ts'
+const { fn } = func
+import * as string from '../../types/string/module.f.ts'
+const { join } = string
+
+const rustField
+    : (field: string) => string
+    = field => `pub ${field},`
+
+const mapRustField = map(rustField)
+
+const rustStruct
+    : (b: list.Thunk<string>) => (name: string) => Text.Block
+    = b => name => [`#[repr(C)]`, `pub struct ${name} {`, mapRustField(b), `}`]
+
+const commaJoin = join(', ')
+
+const ref
+    : (name: string) => string
+    = name => `${name}::Ref`
+
+const obj
+    : (name: string) => string
+    = name => `&${name}::Object`
+
+const self = ['&self']
+
+const paramName
+    : (p: types.Field) => string
+    = ([n]) => n
+
+const callList
+    : (p: types.FieldArray) => list.Thunk<string>
+    = p => map(paramName)(paramList(p))
+
+const call
+    : (p: types.FieldArray) => string
+    = p => commaJoin(callList(p))
+
+const virtualCall
+    : (p: types.FieldArray) => string
+    = p => commaJoin(flat([['self'], callList(p)]))
+
+const super_ = 'super::'
+
+const assign
+    : (m: types.Method) => string
+    = ([n]) => `${n}: Self::${n},`
+
+const mapAssign = map(assign)
+
+const this_ = ['this: &Object']
+
+const rustType
+    : (n: string) => string
+    = n => `pub type ${n} = nanocom::${n}<Interface>;`
+
+type OptionalProperty<T> = T|{}
+
+type Where = {readonly where: readonly string[]}
+
+type WhereContent = OptionalProperty<Where> & {readonly content: Text.Block}
+
+const whereContent
+    : (h: string) => (wh: WhereContent) => Text.Block
+    = h => wh => {
+    const w = 'where' in wh ? [
+        h,
+        `where`,
+        mapComma(wh.where),
+        '{'
+    ]: [`${h} {`]
+    const x = [
+        wh.content,
+        '}',
+    ]
+    return flat([w, x])
+}
+
+type Impl = {
+    readonly param?: string
+    readonly trait: string
+    readonly type: string
+    readonly where?: readonly string[]
+    readonly content: Text.Block
+}
+
+const rustImpl
+    : (impl: Impl) => Text.Block
+    = i => {
+    const p = 'param' in i ? `<${i.param}>` : ''
+    const header = `impl${p} ${i.trait} for ${i.type}`
+    return whereContent(header)(i)
+}
+
+type Trait = {
+    readonly pub?: true
+    readonly type: string
+    readonly where?: readonly string[]
+    readonly content: Text.Block
+}
+
+const comma: (s: string) => string = s => `${s},`
+
+const mapComma = map(comma)
+
+const trait
+    : (t: Trait) => Text.Block
+    = t => {
+    const p = t.pub === true ? 'pub ' : ''
+    const h = `${p}trait ${t.type}`
+    return whereContent(h)(t)
+}
+
+const traitImpl
+    : (t: Trait) => Text.Block
+    = 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: types.Library): Text.Block => {
+
+    const type
+        : (p: string) => (o: (_: string) => string) => (t: types.Type) => string
+        = p => {
+        const f
+            : (o: (_: string) => string) => (t: types.Type) => string
+            = 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: string) => (o: (_: string) => string) => (f: types.Field) => string
+        = 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
+        : (fa: types.FieldArray) => (name: string) => Text.Block
+        = fn(entries)
+            .then(mapField)
+            .then(rustStruct)
+            .result
+
+    const func
+        : (first: readonly string[]) => (p: types.FieldArray) => string
+        = first => p => {
+        const resultStr = '_' in p ? ` -> ${type(super_)(ref)(p._)}` : ''
+        const params = commaJoin(flat([first, mapParam(paramList(p))]))
+        return `(${params})${resultStr}`
+    }
+
+    const virtualFnType
+        : (n: string) => (p: types.FieldArray) => string
+        = n => p => `extern "system" fn${n}${func(this_)(p)}`
+
+    const virtualFn
+        : (m: types.Method) => string
+        = ([n, p]) => `${n}: unsafe ${virtualFnType('')(p)}`
+
+    const mapVirtualFn = map(virtualFn)
+
+    const headerFn
+        : (m: types.Method) => string
+        = ([n, p]) => `fn ${n}${func(self)(p)}`
+
+    const traitFn
+        : (m: types.Method) => string
+        = m => `${headerFn(m)};`
+
+    const mapTraitFn = map(traitFn)
+
+    const implFn
+        : (m: types.Method) => Text.Block
+        = m => {
+        const [n, p] = m
+        return [
+            `${headerFn(m)} {`,
+            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
+            '}'
+        ]
+    }
+
+    const flatMapImplFn = flatMap(implFn)
+
+    const impl
+        : (m: types.Method) => Text.Block
+        = ([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_
+        : (i: types.Interface) => (name: string) => Text.Block
+        = ({ 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
+        : (type: O.Entry<types.Definition>) => Text.Block
+        = ([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.mjs → test.f.ts}

@@ -1,4 +1,4 @@
-import rust from './testlib.f.mjs'
+import rust from './testlib.f.ts'
 
 export default () => {
     const e =

package/com/rust/testlib.f.ts

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

package/com/test/{build.f.mjs → build.f.ts}

@@ -1,47 +1,42 @@
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 const { flat } = list
 
-import cppContent from '../cpp/testlib.f.mjs'
-import csContent from '../cs/testlib.f.mjs'
-import rustContent from '../rust/testlib.f.mjs'
+import cppContent from '../cpp/testlib.f.ts'
+import csContent from '../cs/testlib.f.ts'
+import rustContent from '../rust/testlib.f.ts'
 
-/**
- * @typedef {|
- *  'aix' |
- *  'android' |
- *  'darwin' |
- *  'freebsd' |
- *  'haiku' |
- *  'linux' |
- *  'openbsd' |
- *  'sunos' |
- *  'win32' |
- *  'cygwin' |
- *  'netbsd'
- * } Platform
- */
+type Platform =
+   | 'aix'
+   | 'android'
+   | 'darwin'
+   | 'freebsd'
+   | 'haiku'
+   | 'linux'
+   | 'openbsd'
+   | 'sunos'
+   | 'win32'
+   | 'cygwin'
+   | 'netbsd'
 
-/**
- * @typedef {{
- *  readonly dirname: string
- *  readonly platform: Platform
- * }} NodeJs
- */
+type NodeJs = {
+   readonly dirname: string
+   readonly platform: Platform
+}
+
+type Output ={
+   readonly file: {
+       readonly name: string
+       readonly content: string
+   }
+   readonly line: list.List<list.List<string>>
+}
 
-/**
- * @typedef {{
- *  readonly file: {
- *      readonly name: string
- *      readonly content: string
- *  }
- *  readonly line: list.List<list.List<string>>
- * }} Output
- */
+export type Func = (nodejs: NodeJs) => Output
 
-/** @typedef {(nodejs: NodeJs) => Output} Func */
+const flags
+    : (platform: Platform) => readonly string[]
+    = platform => {
 
-/** @type {(platform: Platform) => readonly string[]} */
-const flags = platform => {
     switch (platform) {
         case 'win32':
             return []
@@ -52,8 +47,10 @@ const flags = platform => {
     }
 }
 
-/** @type {(platform: Platform) => (name: string) => string} */
-const output = platform => name => {
+const output
+    : (platform: Platform) => (name: string) => string
+    = platform => name => {
+
     switch (platform) {
         case 'win32': return `${name}.dll`
         case 'darwin': return `lib${name}.dylib`
@@ -61,8 +58,10 @@ const output = platform => name => {
     }
 }
 
-/** @type {Func} */
-const cpp = ({ dirname, platform }) => ({
+const cpp
+    : Func
+    = ({ dirname, platform }) => ({
+
     file: {
         name: `${dirname}/cpp/_result.hpp`,
         content: cppContent(),
@@ -76,8 +75,10 @@ const cpp = ({ dirname, platform }) => ({
     ],
 })
 
-/** @type {Func} */
-const cs = ({ dirname, platform }) => ({
+const cs
+    : Func
+    = ({ dirname, platform }) => ({
+
     file: {
         name: `${dirname}/cs/_result.cs`,
         content: csContent,
@@ -90,8 +91,9 @@ const cs = ({ dirname, platform }) => ({
     ],
 })
 
-/** @type {Func} */
-const rust = ({ dirname }) => ({
+const rust
+: Func
+= ({ dirname }) => ({
     file: {
         name: `${dirname}/rust/src/_result.rs`,
         content: rustContent,

package/com/test/{build.mjs → build.ts}

@@ -1,14 +1,14 @@
 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'
+import build, * as Build from './build.f.ts'
 const { cpp, cs, rust } = build
-import * as string from '../../types/string/module.f.mjs'
+import * as string from '../../types/string/module.f.ts'
 const { join } = string
 const { log, error } = console
-import * as sgr from '../../text/sgr/module.f.mjs'
+import * as sgr from '../../text/sgr/module.f.ts'
 const { bold, reset } = sgr.codes
-import * as list from '../../types/list/module.f.mjs'
+import * as list from '../../types/list/module.f.ts'
 
 import { fileURLToPath } from 'node:url'
 import { dirname } from 'node:path'
@@ -21,8 +21,9 @@ const nodeJs = {
     platform,
 }
 
-/** @type {(f: Build.Func) => void} */
-const run = f => {
+const run
+    : (f: Build.Func) => void
+    = f => {
     const { file: { name, content }, line } = f(nodeJs)
     log(`${bold}writing: ${name}${reset}`)
     writeFileSync(name, content)

package/com/types/module.f.ts

@@ -0,0 +1,62 @@
+import * as O from '../../types/object/module.f.ts'
+import * as list from '../../types/list/module.f.ts'
+import * as f from '../../types/function/module.f.ts'
+const { compose } = f
+const { filter } = list
+const { entries } = Object
+
+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]
+
+const isParam
+    : (kv: O.Entry<Type>) => boolean
+    = ([name]) => name !== '_'
+
+const filterParam = filter(isParam)
+
+export const paramList
+    : (fa: FieldArray) => list.List<Field>
+    = compose(entries)(filterParam)
+
+export const result
+    : <T>(v: T) => (f: (type: Type) => T) => (fa: FieldArray) => T
+    = v => f => fa => '_' in fa ? f(fa._) : v

package/com/types/{testlib.f.mjs → testlib.f.ts}

@@ -1,6 +1,5 @@
-import * as _ from './module.f.mjs'
+import * as _ from './module.f.ts'
 
-/** @type {_.Library} */
 export default {
     Slice: {
         struct: {
@@ -28,4 +27,4 @@ export default {
             SetManagedStruct: { a: ['ManagedStruct'] },
         },
     }
-}
+} satisfies _.Library

package/commonjs/build/module.f.ts

@@ -0,0 +1,100 @@
+import * as package_ from '../package/module.f.ts'
+import * as module from '../module/module.f.ts'
+const { idToString, dir } = module
+import * as function_ from '../module/function/module.f.ts'
+import * as map from '../../types/map/module.f.ts'
+const { empty: mapEmpty, setReplace } = map
+import * as object from '../../types/object/module.f.ts'
+const { fromMap } = object
+import * as path from '../path/module.f.ts'
+const { parseAndFind } = path
+import * as stringSet from '../../types/string_set/module.f.ts'
+const { set: setSet, contains: setContains, empty: stringSetEmpty } = stringSet
+
+type Config<M> = {
+   readonly packageGet: package_.Get
+   readonly moduleMapInterface: module.MapInterface<M>
+   readonly moduleId: module.Id
+   readonly moduleMap: M
+}
+
+type Result<M> = readonly[module.State, M]
+
+const notFound
+    : <M>(moduleMap: M) => Result<M>
+    = moduleMap => [['error', ['file not found']], moduleMap]
+
+export const getOrBuild
+    :   (compile: function_.Compile) =>
+        (packageGet: package_.Get) =>
+        <M>(moduleMapInterface: module.MapInterface<M>) =>
+        (moduleId: module.Id) =>
+        (moduleMap: M) =>
+        Result<M>
+    = compile => packageGet => moduleMapInterface =>  {
+
+    type M = typeof moduleMapInterface extends module.MapInterface<infer M> ? M : never
+
+    const build
+        :   (buildSet: stringSet.StringSet) =>
+            (moduleId: module.Id) =>
+            (source: string) =>
+            (moduleMap: M) =>
+            Result<M>
+        = buildSet => moduleId => {
+
+        const moduleIdStr = idToString(moduleId)
+        const buildSet1 = setSet(moduleIdStr)(buildSet)
+        const moduleDir = dir(moduleId)
+        const require_
+            : function_.Require<readonly[map.Map<string>, M]>
+            = p => ([requireMap, m]) => {
+            const error
+                : (e: unknown) => function_.Result<readonly[map.Map<string>, M]>
+                = 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 => {
+            const set
+                : (s: module.State) => (m: M) => Result<M>
+                = s => m => [s, moduleMapInterface.setReplace(moduleIdStr)(s)(m)]
+            const error
+                : (e: module.Error) => (m: M) => Result<M>
+                = 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)
+        }
+    }
+
+    const f
+        : (moduleId: module.Id) => (moduleMap: M) => Result<M>
+        = 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
+}