functionalscript 0.0.456 → 0.0.458

package/Cargo.lock

@@ -4,7 +4,7 @@ version = 3
 
 [[package]]
 name = "nanocom"
-version = "0.1.2"
+version = "0.2.0"
 
 [[package]]
 name = "testrust"

package/com/rust/module.f.cjs

@@ -196,7 +196,7 @@ const rust = library => {
         const type = virtualFnType(` ${n}`)(p)
         return [
             `${type} {`,
-            [`unsafe { Self::to_cobject(this) }.${n}(${call(p)})`],
+            [`unsafe { nanocom::CObject::from_object_unchecked(this) }.${n}(${call(p)})`],
             '}'
         ]
     }
@@ -231,7 +231,7 @@ const rust = library => {
                 pub: true,
                 type: 'ClassEx',
                 content: ['const VMT: Vmt = Vmt {',
-                    [   'iunknown: Self::IUNKNOWN,',
+                    [   'iunknown: nanocom::CObject::<Self>::IUNKNOWN,',
                         'interface: Interface {',
                             mapAssign(e),
                         '},',

package/com/rust/nanocom/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "nanocom"
-version = "0.1.2"
+version = "0.2.0"
 edition = "2021"
 description = "Nano-COM, extremly small subset of cross-platform COM"
 authors = ["NatFoam"]

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

@@ -1,14 +1,6 @@
-use crate::{iunknown::IUnknown, CObject, Interface, Object, Ref, Vmt};
+use crate::{Interface, Vmt};
 
 pub trait Class: Sized {
     type Interface: Interface;
     fn static_vmt() -> &'static Vmt<Self::Interface>;
-    const IUNKNOWN: IUnknown<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/nanocom/src/cobject.rs

@@ -7,33 +7,23 @@ use crate::{hresult::HRESULT, iunknown::IUnknown, Class, Interface, Object, Ref,
 
 #[repr(C)]
 pub struct CObject<T: Class> {
-    vmt: &'static Vmt<T::Interface>,
+    object: Object<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: IUnknown<T::Interface> = IUnknown {
         QueryInterface: Self::QueryInterface,
         AddRef: Self::AddRef,
         Release: Self::Release,
     };
 
+    pub unsafe fn from_object_unchecked(this: &Object<T::Interface>) -> &CObject<T> {
+        let p = this as *const Object<T::Interface> as *const CObject<T>;
+        &*p
+    }
+
     #[allow(non_snake_case)]
     extern "system" fn QueryInterface(
         this: &Object<T::Interface>,
@@ -52,7 +42,7 @@ impl<T: Class> CObject<T> {
 
     #[allow(non_snake_case)]
     extern "system" fn AddRef(this: &Object<T::Interface>) -> u32 {
-        unsafe { T::to_cobject(this) }
+        unsafe { Self::from_object_unchecked(this) }
             .counter
             .fetch_add(1, Ordering::Relaxed)
             + 1
@@ -60,7 +50,7 @@ impl<T: Class> CObject<T> {
 
     #[allow(non_snake_case)]
     extern "system" fn Release(this: &Object<T::Interface>) -> u32 {
-        let t = unsafe { T::to_cobject(this) };
+        let t = unsafe { Self::from_object_unchecked(this) };
         match t.counter.fetch_sub(1, Ordering::Relaxed) {
             1 => {
                 let m = t as *const CObject<T> as *mut CObject<T>;
@@ -71,3 +61,30 @@ impl<T: Class> CObject<T> {
         }
     }
 }
+
+pub trait CObjectEx: Class {
+    fn to_cobject(self) -> Ref<Self::Interface> {
+        let c = CObject {
+            object: Object::new(Self::static_vmt()),
+            counter: Default::default(),
+            value: self,
+        };
+        let p = Box::into_raw(Box::new(c));
+        let o = &unsafe { &*p }.object;
+        o.into()
+    }
+}
+
+impl<T: Class> CObjectEx for T {}
+
+impl<'a, T: Class> From<&'a CObject<T>> for &'a Object<T::Interface> {
+    fn from(this: &'a CObject<T>) -> Self {
+        &this.object
+    }
+}
+
+impl<T: Class> From<&CObject<T>> for Ref<T::Interface> {
+    fn from(this: &CObject<T>) -> Self {
+        (&this.object).into()
+    }
+}

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

@@ -9,6 +9,12 @@ mod r#ref;
 mod vmt;
 
 pub use crate::{
-    class::Class, cobject::CObject, guid::GUID, interface::Interface, iunknown::IUnknown,
-    object::Object, r#ref::Ref, vmt::Vmt,
+    class::Class,
+    cobject::{CObject, CObjectEx},
+    guid::GUID,
+    interface::Interface,
+    iunknown::IUnknown,
+    object::Object,
+    r#ref::Ref,
+    vmt::Vmt,
 };

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

@@ -5,6 +5,9 @@ use std::ptr::null;
 pub struct Object<I: 'static = ()>(&'static Vmt<I>);
 
 impl<I> Object<I> {
+    pub fn new(vmt: &'static Vmt<I>) -> Self {
+        Self(vmt)
+    }
     pub unsafe fn iunknown(&self) -> &'static IUnknown<I> {
         &self.0.iunknown
     }

package/com/rust/nanocom/tests/it.rs

@@ -46,10 +46,10 @@ mod library {
         CObject<Self>: IMyEx,
     {
         extern "system" fn A(this: &Object<IMy>) -> Ref<IMy> {
-            unsafe { Self::to_cobject(this) }.A()
+            unsafe { CObject::from_object_unchecked(this) }.A()
         }
         extern "system" fn B(this: &Object<IMy>) -> u32 {
-            unsafe { Self::to_cobject(this) }.B()
+            unsafe { CObject::from_object_unchecked(this) }.B()
         }
     }
 
@@ -68,7 +68,7 @@ mod number {
         type Interface = IMy;
         fn static_vmt() -> &'static Vmt<Self::Interface> {
             static V: Vmt<IMy> = Vmt {
-                iunknown: X::IUNKNOWN,
+                iunknown: CObject::<X>::IUNKNOWN,
                 interface: X::INTERFACE,
             };
             &V
@@ -78,7 +78,7 @@ mod number {
     #[allow(non_snake_case)]
     impl IMyEx for CObject<X> {
         fn A(&self) -> Ref<IMy> {
-            self.to_interface().into()
+            self.into()
         }
         fn B(&self) -> u32 {
             self.value.0
@@ -87,17 +87,17 @@ mod number {
 }
 
 mod use_number {
-    use nanocom::Class;
+    use nanocom::{CObjectEx, Class};
 
     use super::{library::IMyEx, number::X};
 
     #[test]
     fn test() {
-        let a = X(42).cobject_new();
+        let a = X(42).to_cobject();
         let a1 = a.A();
         assert_eq!(a, a1);
         assert_eq!(a.B(), 42);
-        let b = X(43).cobject_new();
+        let b = X(43).to_cobject();
         assert_ne!(a, b);
         assert_eq!(b.B(), 43);
     }
@@ -134,7 +134,7 @@ mod destructor {
         type Interface = IMy;
         fn static_vmt() -> &'static Vmt<Self::Interface> {
             static V: Vmt<IMy> = Vmt {
-                iunknown: X::IUNKNOWN,
+                iunknown: CObject::<X>::IUNKNOWN,
                 interface: X::INTERFACE,
             };
             &V
@@ -144,7 +144,7 @@ mod destructor {
     #[allow(non_snake_case)]
     impl IMyEx for CObject<X> {
         fn A(&self) -> Ref<IMy> {
-            self.to_interface().into()
+            self.into()
         }
         fn B(&self) -> u32 {
             self.value.p.load(Ordering::Relaxed)
@@ -158,7 +158,7 @@ mod use_destructor {
         sync::atomic::{AtomicU32, Ordering},
     };
 
-    use nanocom::Class;
+    use nanocom::CObjectEx;
 
     use super::{destructor::X, library::IMyEx};
 
@@ -167,14 +167,14 @@ mod use_destructor {
         let p = Rc::new(AtomicU32::default());
         {
             assert_eq!(p.load(Ordering::Relaxed), 0);
-            let a = X::new(p.clone()).cobject_new();
+            let a = X::new(p.clone()).to_cobject();
             assert_eq!(p.load(Ordering::Relaxed), 1);
             let a1 = a.A();
             assert_eq!(p.load(Ordering::Relaxed), 1);
             assert_eq!(a, a1);
             assert_eq!(a.B(), 1);
             {
-                let b = X::new(p.clone()).cobject_new();
+                let b = X::new(p.clone()).to_cobject();
                 assert_eq!(p.load(Ordering::Relaxed), 2);
                 assert_ne!(a, b);
                 assert_eq!(b.B(), 2);

package/com/rust/nanocom/tests/itmod.rs

@@ -4,6 +4,8 @@
 
 mod library {
     pub mod IMy {
+        use nanocom::CObject;
+
         pub type Object = nanocom::Object<Interface>;
         pub type Ref = nanocom::Ref<Interface>;
         pub type Vmt = nanocom::Vmt<Interface>;
@@ -37,11 +39,11 @@ mod library {
             nanocom::CObject<Self>: Ex,
         {
             const VMT: Vmt = Vmt {
-                iunknown: Self::IUNKNOWN,
+                iunknown: CObject::<Self>::IUNKNOWN,
                 interface: Interface {
                     A: Self::A,
                     B: Self::B,
-                }
+                },
             };
         }
 
@@ -52,10 +54,10 @@ mod library {
             nanocom::CObject<Self>: Ex,
         {
             extern "system" fn A(this: &Object) -> Ref {
-                unsafe { Self::to_cobject(this) }.A()
+                unsafe { CObject::from_object_unchecked(this) }.A()
             }
             extern "system" fn B(this: &Object) -> u32 {
-                unsafe { Self::to_cobject(this) }.B()
+                unsafe { CObject::from_object_unchecked(this) }.B()
             }
         }
 
@@ -83,7 +85,7 @@ mod number {
 
     impl IMy::Ex for CObject<X> {
         fn A(&self) -> IMy::Ref {
-            self.to_interface().into()
+            self.into()
         }
         fn B(&self) -> u32 {
             self.value.0
@@ -92,7 +94,7 @@ mod number {
 }
 
 mod use_number {
-    use nanocom::Class;
+    use nanocom::CObjectEx;
 
     use crate::library::IMy::Ex;
 
@@ -100,11 +102,11 @@ mod use_number {
 
     #[test]
     fn test() {
-        let a = X(42).cobject_new();
+        let a = X(42).to_cobject();
         let a1 = a.A();
         assert_eq!(a, a1);
         assert_eq!(a.B(), 42);
-        let b = X(43).cobject_new();
+        let b = X(43).to_cobject();
         assert_ne!(a, b);
         assert_eq!(b.B(), 43);
     }
@@ -149,7 +151,7 @@ mod destructor {
 
     impl IMy::Ex for CObject<X> {
         fn A(&self) -> IMy::Ref {
-            self.to_interface().into()
+            self.into()
         }
         fn B(&self) -> u32 {
             self.value.p.load(Ordering::Relaxed)
@@ -163,7 +165,7 @@ mod use_destructor {
         sync::atomic::{AtomicU32, Ordering},
     };
 
-    use nanocom::Class;
+    use nanocom::CObjectEx;
 
     use crate::library::IMy::Ex;
 
@@ -174,14 +176,14 @@ mod use_destructor {
         let p = Rc::new(AtomicU32::default());
         {
             assert_eq!(p.load(Ordering::Relaxed), 0);
-            let a = X::new(p.clone()).cobject_new();
+            let a = X::new(p.clone()).to_cobject();
             assert_eq!(p.load(Ordering::Relaxed), 1);
             let a1 = a.A();
             assert_eq!(p.load(Ordering::Relaxed), 1);
             assert_eq!(a, a1);
             assert_eq!(a.B(), 1);
             {
-                let b = X::new(p.clone()).cobject_new();
+                let b = X::new(p.clone()).to_cobject();
                 assert_eq!(p.load(Ordering::Relaxed), 2);
                 assert_ne!(a, b);
                 assert_eq!(b.B(), 2);

package/com/rust/test.f.cjs

@@ -67,7 +67,7 @@ module.exports = () => {
         '        nanocom::CObject<Self>: Ex,\n' +
         '    {\n' +
         '        const VMT: Vmt = Vmt {\n' +
-        '            iunknown: Self::IUNKNOWN,\n' +
+        '            iunknown: nanocom::CObject::<Self>::IUNKNOWN,\n' +
         '            interface: Interface {\n' +
         '                GetSlice: Self::GetSlice,\n' +
         '                SetSlice: Self::SetSlice,\n' +
@@ -91,25 +91,25 @@ module.exports = () => {
         '        nanocom::CObject<Self>: Ex,\n' +
         '    {\n' +
         '        extern "system" fn GetSlice(this: &Object) -> super::Slice {\n' +
-        '            unsafe { Self::to_cobject(this) }.GetSlice()\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetSlice()\n' +
         '        }\n' +
         '        extern "system" fn SetSlice(this: &Object, slice: super::Slice) {\n' +
-        '            unsafe { Self::to_cobject(this) }.SetSlice(slice)\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetSlice(slice)\n' +
         '        }\n' +
         '        extern "system" fn GetUnsafe(this: &Object) -> *const bool {\n' +
-        '            unsafe { Self::to_cobject(this) }.GetUnsafe()\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 { Self::to_cobject(this) }.SetUnsafe(p, size)\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 { Self::to_cobject(this) }.Some(p)\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.Some(p)\n' +
         '        }\n' +
         '        extern "system" fn GetIMy(this: &Object) -> super::IMy::Ref {\n' +
-        '            unsafe { Self::to_cobject(this) }.GetIMy()\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.GetIMy()\n' +
         '        }\n' +
         '        extern "system" fn SetManagedStruct(this: &Object, a: super::ManagedStruct) {\n' +
-        '            unsafe { Self::to_cobject(this) }.SetManagedStruct(a)\n' +
+        '            unsafe { nanocom::CObject::from_object_unchecked(this) }.SetManagedStruct(a)\n' +
         '        }\n' +
         '    }\n' +
         '    impl<T> PrivateClassEx for T\n' +

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

@@ -40,4 +40,4 @@ impl _result::IMy::Ex for nanocom::CObject<My> {
     fn SetManagedStruct(&self, a: _result::ManagedStruct) {
         todo!()
     }
-}
+}

package/fsm/module.f.cjs

@@ -14,15 +14,10 @@ const byteSet = require('../types/byte_set/module.f.cjs')
  * }} Dfa
  */
 
-/** @type {(faId: string) => string} */
-const escape = faId => faId.replaceAll('\\', '\\\\').replaceAll('|', '\\|')
-
 /** @type {(grammar: Grammar) => Dfa} */
 const dfa = grammar => todo()
 
 module.exports = {
-    /** @readonly */
-    escape,
     /** @readonly */
     dfa,
 }

package/fsm/test.f.cjs

@@ -1,14 +1,5 @@
 const _ = require('./module.f.cjs')
 
 module.exports = {
-    escape: [
-        () => {
-            const result = _.escape('abc')
-            if (result !== 'abc') { throw result }
-        },
-        () => {
-            const result = _.escape('\\a|b|c\\')
-            if (result !== '\\\\a\\|b\\|c\\\\') { throw result }
-        }
-    ]
+
 }

package/package.json

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

package/types/byte_set/module.f.cjs

@@ -1,4 +1,8 @@
 const { fn } = require('../function/module.f.cjs')
+const rangeMap = require('../range_map/module.f.cjs')
+const sortedSet = require('../sorted_set/module.f.cjs')
+const list = require('../list/module.f.cjs')
+const { reverse, countdown, flat, map } = list
 
 /** @typedef {bigint} ByteSet */
 /** @typedef {number} Byte */
@@ -42,6 +46,20 @@ const setRange = fn(range).then(union).result
 /** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
 const unset = n => s => difference(s)(one(n))
 
+const counter = reverse(countdown(256))
+
+/** @type {(n: ByteSet) => (s: string) => (i: number) => rangeMap.RangeMap<sortedSet.SortedSet<string>>} */
+const toRangeMapOp = n => s => i =>
+{
+    const current = has(i + 1)(n)
+    const prev = has(i)(n)
+    if (current === prev) { return undefined }
+    return [[prev ? [s] : [], i]]
+}
+
+/** @type {(n: ByteSet) => (s: string) => rangeMap.RangeMap<sortedSet.SortedSet<string>>} */
+const toRangeMap = n => s => flat(map(toRangeMapOp(n)(s))(counter))
+
 module.exports = {
     /** @readonly */
     empty,
@@ -61,4 +79,6 @@ module.exports = {
     range,
     /** @readonly */
     complement,
+    /** @readonly */
+    toRangeMap,
 }

package/types/byte_set/test.f.cjs

@@ -1,5 +1,11 @@
 const _ = require('./module.f.cjs')
 const { every, countdown, map } = require('../list/module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../object/module.f.cjs')
+const { toArray } = require('../list/module.f.cjs')
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
 
 module.exports = {
     has: [
@@ -52,5 +58,25 @@ module.exports = {
             const r = _.complement(_.universe)
             if (r !== _.empty) { throw r }
         },
-    }
+    },
+    toRangeMap: [
+        () => {
+            const result = stringify(toArray(_.toRangeMap(_.empty)('a')))
+            if (result !== '[]') { throw result }
+        },
+        () => {
+            const s = _.set(0)(_.empty)
+            const result = stringify(toArray(_.toRangeMap(s)('a')))
+            if (result !== '[[["a"],0]]') { throw result }
+        },
+        () => {
+            const s = _.setRange([1,2])(_.empty)
+            const result = stringify(toArray(_.toRangeMap(s)('a')))
+            if (result !== '[[[],0],[["a"],2]]') { throw result }
+        },
+        () => {
+            const result = stringify(toArray(_.toRangeMap(_.universe)('a')))
+            if (result !== '[[["a"],255]]') { throw result }
+        },
+    ]
 }