functionalscript 0.0.426 → 0.0.428

package/Cargo.lock

@@ -5,3 +5,10 @@ version = 3
 [[package]]
 name = "nanocom"
 version = "0.1.2"
+
+[[package]]
+name = "rtest"
+version = "0.1.0"
+dependencies = [
+ "nanocom",
+]

package/Cargo.toml

@@ -1,4 +1,5 @@
 [workspace]
 members = [
-    "com/rust/nanocom"
+    "com/rust/nanocom",
+    "com/rust/rtest"
 ]

package/com/cpp/test/build.cjs

@@ -1,7 +1,7 @@
 const fs = require('node:fs')
 const cp = require('node:child_process')
 const os = require('node:os');
-const cpp = require('../testlib.f.cjs').result
+const cpp = require('../test.f.cjs').result
 const { string: { join }, list: { flat } } = require('../../../types/module.f.cjs')
 
 fs.writeFileSync('_result.hpp', cpp)

package/com/cs/test/build.cjs

@@ -1,6 +1,6 @@
 const fs = require('node:fs')
 const cp = require('node:child_process')
-const cs = require('../testlib.f.cjs').result
+const cs = require('../test.f.cjs').result
 
 fs.writeFileSync('_result.cs', cs)
 try {

package/com/rust/module.f.cjs

@@ -3,7 +3,7 @@ const { paramList } = types
 const text = require('../../text/module.f.cjs')
 const object = require('../../types/object/module.f.cjs')
 const list = require('../../types/list/module.f.cjs')
-const { flat, map, flatMap } = list
+const { flat, map, flatMap, isEmpty } = list
 const { entries } = Object
 const { fn } = require('../../types/function/module.f.cjs')
 const { join } = require('../../types/string/module.f.cjs')
@@ -29,15 +29,100 @@ 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 call = p => commaJoin(flat([['self'], map(paramName)(paramList(p))]))
+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 super_ = 'super::'
+const this_ = ['this: &Object']
+
+/** @type {(n: string) => string} */
+const rustType = n => `pub type ${n} = nanocom::${n}<Interface>;`
+
+/**
+ * @typedef {{
+ *  readonly where?: readonly string[]
+ *  readonly content: text.Block
+ * }} WhereContent
+ */
+
+/** @type {(h: string) => (wh: WhereContent) => text.Block} */
+const whereContent = h => ({ where, content }) => {
+    const w = isEmpty(where) ? [`${h} {`] : [
+        h,
+        `where`,
+        mapComma(where),
+        '{'
+    ]
+    const x = [
+        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 = i.param === undefined ? '' : `<${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} */
 const rust = library => {
@@ -78,6 +163,14 @@ const rust = library => {
         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)}`
 
@@ -91,55 +184,61 @@ const rust = library => {
         const [n, p] = m
         return [
             `${headerFn(m)} {`,
-            [`unsafe { (self.interface().${n})(${call(p)}) }`],
+            [`unsafe { (self.interface().${n})(${virtualCall(p)}) }`],
             '}'
         ]
     }
 
     const flatMapImplFn = flatMap(implFn)
 
-    /** @type {(i: types.Interface) => (name: string) => text.Block} */
-    const interface_ = ({ interface: i, guid }) => name => {
+    /** @type {(m: types.Method) => text.Block} */
+    const impl = ([n, p]) => {
+        const type = virtualFnType(` ${n}`)(p)
+        return [
+            `${type} {`,
+            [`unsafe { Self::to_cobject(this) }.${n}(${call(p)})`],
+            '}'
+        ]
+    }
 
-        const this_ = ['this: &Object']
+    const flatMapImpl = flatMap(impl)
 
-        /** @type {(m: types.Method) => string} */
-        const virtualFn = ([n, p]) => `${n}: unsafe extern "system" fn${func(this_)(p)}`
+    /** @type {(i: types.Interface) => (name: string) => text.Block} */
+    const interface_ = ({ interface: i, guid }) => name => {
 
         const e = entries(i)
 
-        const nameEx = `${name}Ex`
-
-        const nameVmt = `${name}Vmt`
-
         return [
             `pub mod ${name} {`,
             [
-                'type Object = nanocom::Object<Interface>;',
-                'type Ref = nanocom::Ref<Interface>;',
-                'type Vmt = nanocom::Vmt<Interface>;',
+                rustType('Object'),
+                rustType('Ref'),
+                rustType('Vmt'),
             ],
-            rustStruct(map(virtualFn)(e))('Interface'),
-            [   'impl nanocom::Interface for Interface {',
-                [   `const GUID: nanocom::GUID = 0x${guid.replaceAll('-', '_')};`],
-                '}',
-                'pub trait Ex {',
-                mapTraitFn(e),
-                '}',
-                'impl Ex for Object {',
-                flatMapImplFn(e),
-                '}',
-                'pub trait ClassEx: nanocom::Class<Interface = Interface>',
-                'where',
-                [   'nanocom::CObject<Self>: Ex,'],
-                '{',
-                [   `const INTERFACE: Interface = Interface {`,
+            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 INTERFACE: Interface = Interface {`,
                     mapAssign(e),
                     '};'
-                ],
-                '}',
-                'impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}',
-            ],
+                ]
+            }),
+            traitImpl({
+                type: 'PrivateClassEx',
+                content: flatMapImpl(e)
+            }),
             '}'
         ]
     }

package/com/rust/test.f.cjs

@@ -3,74 +3,113 @@ const { flat } = require('../../text/module.f.cjs')
 const { join } = require('../../types/string/module.f.cjs')
 const library = require('../types/testlib.f.cjs')
 
-module.exports = () => {
-    const e =
-        '#![allow(non_snake_case)]\n' +
-        '#[repr(C)]\n' +
-        'pub struct Slice {\n' +
-        '    pub Start: *const u8,\n' +
-        '    pub Size: usize,\n' +
-        '    pub M: IMy::Ref,\n' +
-        '}\n' +
-        'pub mod IMy {\n' +
-        '    type Object = nanocom::Object<Interface>;\n' +
-        '    type Ref = nanocom::Ref<Interface>;\n' +
-        '    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) -> super::IMy::Ref,\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) -> super::IMy::Ref;\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) -> super::IMy::Ref {\n' +
-        '            unsafe { (self.interface().GetIMy)(self) }\n' +
-        '        }\n' +
-        '    }\n' +
-        '    pub trait ClassEx: nanocom::Class<Interface = Interface>\n' +
-        '    where\n' +
-        '        nanocom::CObject<Self>: Ex,\n' +
-        '    {\n' +
-        '        const INTERFACE: 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' +
-        '        };\n' +
-        '    }\n' +
-        '    impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}\n' +
-        '}'
-    const r = join('\n')(flat('    ')(rust(library)))
-    if (r !== e) { throw [e, r] }
-}
+module.exports = {
+    result: () => {
+        const e =
+            '#![allow(non_snake_case)]\n' +
+            '#[repr(C)]\n' +
+            'pub struct Slice {\n' +
+            '    pub Start: *const u8,\n' +
+            '    pub Size: usize,\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) -> super::IMy::Ref,\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) -> super::IMy::Ref;\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) -> super::IMy::Ref {\n' +
+            '            unsafe { (self.interface().GetIMy)(self) }\n' +
+            '        }\n' +
+            '    }\n' +
+            '    pub trait ClassEx\n' +
+            '    where\n' +
+            '        Self: nanocom::Class<Interface = Interface>,\n' +
+            '        nanocom::CObject<Self>: Ex,\n' +
+            '    {\n' +
+            '        const INTERFACE: 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' +
+            '        };\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 { Self::to_cobject(this) }.GetSlice()\n' +
+            '        }\n' +
+            '        extern "system" fn SetSlice(this: &Object, slice: super::Slice) {\n' +
+            '            unsafe { Self::to_cobject(this) }.SetSlice(slice)\n' +
+            '        }\n' +
+            '        extern "system" fn GetUnsafe(this: &Object) -> *const bool {\n' +
+            '            unsafe { Self::to_cobject(this) }.GetUnsafe()\n' +
+            '        }\n' +
+            '        extern "system" fn SetUnsafe(this: &Object, p: *const super::Slice, size: u32) {\n' +
+            '            unsafe { Self::to_cobject(this) }.SetUnsafe(p, size)\n' +
+            '        }\n' +
+            '        extern "system" fn Some(this: &Object, p: &super::IMy::Object) -> bool {\n' +
+            '            unsafe { Self::to_cobject(this) }.Some(p)\n' +
+            '        }\n' +
+            '        extern "system" fn GetIMy(this: &Object) -> super::IMy::Ref {\n' +
+            '            unsafe { Self::to_cobject(this) }.GetIMy()\n' +
+            '        }\n' +
+            '    }\n' +
+            '    impl<T> PrivateClassEx for T\n' +
+            '    where\n' +
+            '        Self: nanocom::Class<Interface = Interface>,\n' +
+            '        nanocom::CObject<Self>: Ex,\n' +
+            '    {\n' +
+            '    }\n' +
+            '}'
+        const r = join('\n')(flat('    ')(rust(library)))
+        if (r !== e) { throw [e, r] }
+        return r
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.426",
+  "version": "0.0.428",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "module.f.cjs",
   "scripts": {

package/test.mjs

@@ -65,7 +65,7 @@ const load = async () => {
                         await f(file)
                     }
                 } else if (name.endsWith('.f.cjs')) {
-                    console.log(`loading ${file}`)
+                    // console.log(`loading ${file}`)
                     const source = await readFile(file, 'utf8')
                     map.push([file, Function('module', 'require', `"use strict";${source}`)])
                 }
@@ -107,7 +107,7 @@ const build = async () => {
             const module = {
                 dependencies: {}
             }
-            console.log(`${i}building ${pathStr}`)
+            // console.log(`${i}building ${pathStr}`)
             const getModule = req(newBase)(`${i}| `)
             const newReq = s => {
                 const [p, result] = getModule(s)
@@ -130,10 +130,12 @@ const modules = await build()
 
 // graph
 
+/*
 for (const [k, v] of Object.entries(modules)) {
     console.log(`: ${k}`)
     console.log(Object.keys(v.dependencies))
 }
+*/
 
 // test runner.