functionalscript 0.0.410 → 0.0.411

package/Cargo.lock

@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "com"
+version = "0.1.0"
+
+[[package]]
+name = "rstest"
+version = "0.1.0"
+dependencies = [
+ "com",
+]

package/Cargo.toml

@@ -0,0 +1,5 @@
+[workspace]
+members = [
+    "com/rust/com",
+    "com/rust/com/rstest",
+]

package/com/rust/com/Cargo.lock

@@ -0,0 +1,7 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "com"
+version = "0.1.0"

package/com/rust/com/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "com"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]

package/com/rust/com/rstest/Cargo.lock

@@ -0,0 +1,14 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "com"
+version = "0.1.0"
+
+[[package]]
+name = "rstest"
+version = "0.1.0"
+dependencies = [
+ "com",
+]

package/com/rust/com/rstest/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "rstest"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+com = { path = ".." }

package/com/rust/com/rstest/src/lib.rs

@@ -0,0 +1,109 @@
+#[cfg(test)]
+mod test {
+    // interface definition:
+
+    mod library {
+        use com::{CObject, Class, Interface, Object, Ref, GUID};
+
+        #[allow(non_snake_case)]
+        #[repr(C)]
+        pub struct IMy {
+            pub A: unsafe extern "stdcall" fn(this: &Object<IMy>) -> Ref<IMy>,
+            pub B: unsafe extern "stdcall" fn(this: &Object<IMy>) -> u32,
+        }
+
+        impl Interface for IMy {
+            const GUID: GUID = 0x01234567_89AB_CDEF_0123_456789ABCDEF;
+        }
+
+        #[allow(non_snake_case)]
+        pub trait IMyEx {
+            fn A(&self) -> Ref<IMy>;
+            fn B(&self) -> u32;
+        }
+
+        #[allow(non_snake_case)]
+        impl IMyEx for Object<IMy> {
+            fn A(&self) -> Ref<IMy> {
+                unsafe { (self.interface().A)(self) }
+            }
+            fn B(&self) -> u32 {
+                unsafe { (self.interface().B)(self) }
+            }
+        }
+
+        pub trait IMyVmt: Class<Interface = IMy>
+        where
+            CObject<Self>: IMyEx,
+        {
+            const INTERFACE: IMy = IMy {
+                A: Self::A,
+                B: Self::B,
+            };
+        }
+
+        impl<T: Class<Interface = IMy>> IMyVmt for T where CObject<T>: IMyEx {}
+
+        #[allow(non_snake_case)]
+        trait IMyVmtFn: Class<Interface = IMy>
+        where
+            CObject<Self>: IMyEx,
+        {
+            extern "stdcall" fn A(this: &Object<IMy>) -> Ref<IMy> {
+                unsafe { Self::to_cobject(this) }.A()
+            }
+            extern "stdcall" fn B(this: &Object<IMy>) -> u32 {
+                unsafe { Self::to_cobject(this) }.B()
+            }
+        }
+
+        impl<T: Class<Interface = IMy>> IMyVmtFn for T where CObject<T>: IMyEx {}
+    }
+
+    // interface implementation
+    mod x {
+        use com::{CObject, Class, Ref, Vmt};
+
+        use super::library::{IMy, IMyEx, IMyVmt};
+
+        pub struct X(pub u32);
+
+        impl Class for X {
+            type Interface = IMy;
+            fn static_vmt() -> &'static Vmt<Self::Interface> {
+                static V: Vmt<IMy> = Vmt {
+                    iunknown: X::IUNKNOWN,
+                    interface: X::INTERFACE,
+                };
+                &V
+            }
+        }
+
+        #[allow(non_snake_case)]
+        impl IMyEx for CObject<X> {
+            fn A(&self) -> Ref<IMy> {
+                self.to_interface().into()
+            }
+            fn B(&self) -> u32 {
+                self.value.0
+            }
+        }
+    }
+
+    mod using {
+        use com::Class;
+
+        use crate::test::{library::IMyEx, x::X};
+
+        #[test]
+        fn test() {
+            let a = X(42).cobject_new();
+            let a1 = a.A();
+            assert_eq!(a, a1);
+            assert_eq!(a.B(), 42);
+            let b = X(43).cobject_new();
+            assert_ne!(a, b);
+            assert_eq!(b.B(), 43);
+        }
+    }
+}

package/com/rust/com/src/class.rs

@@ -0,0 +1,14 @@
+use crate::{iunknownvmt::IUnknownVmt, CObject, Interface, Object, Ref, Vmt};
+
+pub trait Class: Sized {
+    type Interface: Interface;
+    fn static_vmt() -> &'static Vmt<Self::Interface>;
+    const IUNKNOWN: IUnknownVmt<Self::Interface> = CObject::<Self>::IUNKNOWN;
+    fn cobject_new(self) -> Ref<Self::Interface> {
+        CObject::new(self)
+    }
+    unsafe fn to_cobject(this: &Object<Self::Interface>) -> &CObject<Self> {
+        let p = this as *const Object<Self::Interface> as *const CObject<Self>;
+        &*p
+    }
+}

package/com/rust/com/src/cobject.rs

@@ -0,0 +1,76 @@
+use std::{
+    ptr::null,
+    sync::atomic::{AtomicU32, Ordering},
+};
+
+use crate::{
+    hresult::HRESULT, iunknown::IUnknown, iunknownvmt::IUnknownVmt, Class, Interface, Object, Ref,
+    Vmt,
+};
+
+#[repr(C)]
+pub struct CObject<T: Class> {
+    vmt: &'static Vmt<T::Interface>,
+    counter: AtomicU32,
+    pub value: T,
+}
+
+impl<T: Class> CObject<T> {
+    pub fn new(value: T) -> Ref<T::Interface> {
+        let c = CObject {
+            vmt: T::static_vmt(),
+            counter: Default::default(),
+            value,
+        };
+        let p = Box::into_raw(Box::new(c));
+        unsafe { &*p }.to_interface().into()
+    }
+
+    pub fn to_interface(&self) -> &Object<T::Interface> {
+        let p = self as *const Self as *const Object<T::Interface>;
+        unsafe { &*p }
+    }
+
+    pub const IUNKNOWN: IUnknownVmt<T::Interface> = IUnknownVmt {
+        QueryInterface: Self::QueryInterface,
+        AddRef: Self::AddRef,
+        Release: Self::Release,
+    };
+
+    #[allow(non_snake_case)]
+    extern "stdcall" fn QueryInterface(
+        this: &Object<T::Interface>,
+        riid: &u128,
+        ppv_object: &mut *const Object<IUnknown>,
+    ) -> HRESULT {
+        let (p, r) = if *riid == IUnknown::GUID || *riid == T::Interface::GUID {
+            Self::AddRef(this);
+            (this.to_iunknown() as *const Object<IUnknown>, HRESULT::S_OK)
+        } else {
+            (null(), HRESULT::E_NOINTERFACE)
+        };
+        *ppv_object = p;
+        r
+    }
+
+    #[allow(non_snake_case)]
+    extern "stdcall" fn AddRef(this: &Object<T::Interface>) -> u32 {
+        unsafe { T::to_cobject(this) }
+            .counter
+            .fetch_add(1, Ordering::Relaxed)
+            + 1
+    }
+
+    #[allow(non_snake_case)]
+    extern "stdcall" fn Release(this: &Object<T::Interface>) -> u32 {
+        let t = unsafe { T::to_cobject(this) };
+        match t.counter.fetch_sub(1, Ordering::Relaxed) {
+            1 => {
+                let m = t as *const CObject<T> as *mut CObject<T>;
+                unsafe { Box::from_raw(m) };
+                0
+            }
+            x => x - 1,
+        }
+    }
+}

package/com/rust/com/src/guid.rs

@@ -0,0 +1 @@
+pub type GUID = u128;

package/com/rust/com/src/hresult.rs

@@ -0,0 +1,7 @@
+#[allow(non_camel_case_types)]
+#[repr(u32)]
+#[derive(Debug)]
+pub enum HRESULT {
+    S_OK = 0,
+    E_NOINTERFACE = 0x80004002,
+}

package/com/rust/com/src/interface.rs

@@ -0,0 +1,5 @@
+use crate::guid::GUID;
+
+pub trait Interface: 'static {
+    const GUID: GUID;
+}

package/com/rust/com/src/iunknown.rs

@@ -0,0 +1,7 @@
+use crate::{guid::GUID, interface::Interface};
+
+pub struct IUnknown();
+
+impl Interface for IUnknown {
+    const GUID: GUID = 0x00000000_0000_0000_C000_000000000046;
+}

package/com/rust/com/src/iunknownvmt.rs

@@ -0,0 +1,13 @@
+use crate::{hresult::HRESULT, iunknown::IUnknown, Object, GUID};
+
+#[allow(non_snake_case)]
+#[repr(C)]
+pub struct IUnknownVmt<I: 'static> {
+    pub QueryInterface: unsafe extern "stdcall" fn(
+        this: &Object<I>,
+        riid: &GUID,
+        ppv_object: &mut *const Object<IUnknown>,
+    ) -> HRESULT,
+    pub AddRef: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
+    pub Release: unsafe extern "stdcall" fn(this: &Object<I>) -> u32,
+}

package/com/rust/com/src/lib.rs

@@ -0,0 +1,15 @@
+mod class;
+mod cobject;
+mod guid;
+mod hresult;
+mod interface;
+mod iunknown;
+mod iunknownvmt;
+mod object;
+mod r#ref;
+mod vmt;
+
+pub use crate::{
+    class::Class, cobject::CObject, guid::GUID, interface::Interface, object::Object, r#ref::Ref,
+    vmt::Vmt,
+};

package/com/rust/com/src/object.rs

@@ -0,0 +1,34 @@
+use crate::{
+    hresult::HRESULT, interface::Interface, iunknown::IUnknown, iunknownvmt::IUnknownVmt,
+    r#ref::Ref, vmt::Vmt,
+};
+use std::ptr::null;
+
+#[repr(C)]
+pub struct Object<I: 'static>(&'static Vmt<I>);
+
+impl<I> Object<I> {
+    pub unsafe fn iunknown(&self) -> &'static IUnknownVmt<I> {
+        &self.0.iunknown
+    }
+    pub unsafe fn interface(&self) -> &'static I {
+        &self.0.interface
+    }
+    pub fn to_iunknown(&self) -> &Object<IUnknown> {
+        let p = self as *const Object<I> as *const Object<IUnknown>;
+        unsafe { &*p }
+    }
+    pub fn query_interface<J: Interface>(&self) -> Result<Ref<J>, HRESULT> {
+        let mut p = null();
+        match unsafe { (self.0.iunknown.QueryInterface)(self, &J::GUID, &mut p) } {
+            HRESULT::S_OK => {
+                let r = p as *const Object<J>;
+                Ok(unsafe { Ref::from_raw(r) })
+            }
+            e => Err(e),
+        }
+    }
+    pub fn query_iunknown(&self) -> Ref<IUnknown> {
+        self.query_interface().unwrap()
+    }
+}

package/com/rust/com/src/ref.rs

@@ -0,0 +1,53 @@
+use std::{cmp::Eq, fmt::Debug, ops::Deref};
+
+use crate::object::Object;
+
+#[repr(transparent)]
+pub struct Ref<I: 'static>(*const Object<I>);
+
+impl<I: 'static> Ref<I> {
+    pub unsafe fn from_raw(p: *const Object<I>) -> Ref<I> {
+        Ref(p)
+    }
+}
+
+impl<I> Deref for Ref<I> {
+    type Target = Object<I>;
+    fn deref(&self) -> &Self::Target {
+        let p = self.0;
+        unsafe { &*p }
+    }
+}
+
+impl<I> Drop for Ref<I> {
+    fn drop(&mut self) {
+        unsafe { (self.iunknown().Release)(self) };
+    }
+}
+
+impl<I> Clone for Ref<I> {
+    fn clone(&self) -> Self {
+        self.deref().into()
+    }
+}
+
+impl<I> From<&Object<I>> for Ref<I> {
+    fn from(this: &Object<I>) -> Self {
+        unsafe { (this.iunknown().AddRef)(this) };
+        Self(this)
+    }
+}
+
+impl<I> Debug for Ref<I> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_tuple("Ref").field(&self.0).finish()
+    }
+}
+
+impl<I> PartialEq for Ref<I> {
+    fn eq(&self, other: &Self) -> bool {
+        self.0 == other.0
+    }
+}
+
+impl<I> Eq for Ref<I> {}

package/com/rust/com/src/vmt.rs

@@ -0,0 +1,7 @@
+use crate::iunknownvmt::IUnknownVmt;
+
+#[repr(C)]
+pub struct Vmt<I: 'static> {
+    pub iunknown: IUnknownVmt<I>,
+    pub interface: I,
+}

package/com/rust/module.f.cjs

@@ -0,0 +1,10 @@
+const types = require('../types/module.f.cjs')
+const text = require('../../text/module.f.cjs')
+
+/** @type {(name: string) => (library: types.Library) => text.Block} */
+const rust = name => library => []
+
+module.exports = {
+    /** @readonly */
+    rust,
+}

package/com/rust/test.f.cjs

@@ -0,0 +1,11 @@
+const { rust } = require('./module.f.cjs')
+const { flat } = require('../../text/module.f.cjs')
+const { join } = require('../../types/string/module.f.cjs')
+const library = require('../types/test.f.cjs')
+
+{
+    const r = join('\n')(flat('    ')(rust('My')(library)))
+    if (r !== '') { throw r }
+}
+
+module.exports = {}

package/doc/vm.md

@@ -68,27 +68,6 @@ Least used letters in English: Q, J, Z and X.
 
 Starts with `0xFFF`
 
-- `50`:
-  - `48`: stringUInt48 (0..281_474_976_710_655)
-  - `48`: 8 x 6 string
-  - `48`: `42` 7 x 6 string
-  - `48`: 6 x 8 string
-- `50`:
-  - `48`: `45` 5 x 9 string
-  - `48`: 4 x 12 string
-  - `48`: 3 x 16 string
-  - `48`: `32`: 2 x 16 string
-- `50`:
-  - `48`: `16`: 1 x 16 string
-  - `48`: `0`: ""
-  - `48`: false
-  - `48`: true
-- `50`:
-  - `48`: ptr
-  - `48`: bigInt48 (140_737_488_355_328..140_737_488_355_327)
-  - `48`: undefined
-  - `48`: `-inf`
-
 |      |  |             |type       |
 |------|--|-------------|-----------|
 |`1111`|48|stringUInt48 |`string`   |

package/html/module.f.cjs

@@ -3,9 +3,7 @@ const { map, flatMap, flat, concat: listConcat } = list
 const { concat: stringConcat } = require('../types/string/module.f.cjs')
 const object = require('../types/object/module.f.cjs')
 const { compose } = require('../types/function/module.f.cjs')
-const encoding = require('../text/utf16/module.f.cjs');
-const { stringToList } = encoding
-
+const { stringToList } = require('../text/utf16/module.f.cjs')
 const { fromCharCode } = String
 const { entries } = Object
 

package/json/module.f.cjs

@@ -1,10 +1,10 @@
 const list = require('../types/list/module.f.cjs')
-const { next, flat, reduce: fold, map } = list
+const { next, flat, reduce, map, empty } = list
 const { concat } = require('../types/string/module.f.cjs')
 const object = require('../types/object/module.f.cjs')
 const { at } = object
 const operator = require('../types/function/operator/module.f.cjs')
-const { compose } = require('../types/function/module.f.cjs')
+const { compose, fn } = require('../types/function/module.f.cjs')
 const { entries } = Object
 
 /**
@@ -54,7 +54,7 @@ const comma = [',']
 const joinOp = b => prior => flat([prior, comma, b])
 
 /** @type {(input: list.List<list.List<string>>) => list.List<string>} */
-const join = fold(joinOp)([])
+const join = reduce(joinOp)(empty)
 
 /** @type {(open: string) => (close: string) => (input: list.List<list.List<string>>) => list.List<string>} */
 const wrap = open => close => {
@@ -83,7 +83,11 @@ const serialize = sort => {
     ])
     const mapPropertySerialize = map(propertySerialize)
     /** @type {(object: Object) => list.List<string>} */
-    const objectSerialize = input => objectWrap(mapPropertySerialize(sort(entries(input))))
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result
     /** @type {(value: Unknown) => list.List<string>} */
     const f = value => {
         switch (typeof value) {
@@ -97,9 +101,7 @@ const serialize = sort => {
             }
         }
     }
-    const mapF = map(f)
-    /** @type {(input: Array) => list.List<string>} */
-    const arraySerialize = compose(mapF)(arrayWrap)
+    const arraySerialize = compose(map(f))(arrayWrap)
     return f
 }
 

package/package.json

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

package/test.f.cjs

@@ -27,6 +27,7 @@ require('./text/utf16/test.f.cjs')
 require('./com/cs/test.f.cjs')
 require('./com/cpp/test.f.cjs')
 require('./nodejs/version/test.f.cjs')
+require('./com/rust/test.f.cjs')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }