functionalscript 0.0.443 → 0.0.445

package/com/rust/module.f.cjs

@@ -230,8 +230,12 @@ const rust = library => {
             traitImpl({
                 pub: true,
                 type: 'ClassEx',
-                content: [`const INTERFACE: Interface = Interface {`,
-                    mapAssign(e),
+                content: ['const VMT: Vmt = Vmt {',
+                    [   'iunknown: Self::IUNKNOWN,',
+                        'interface: Interface {',
+                            mapAssign(e),
+                        '},',
+                    ],
                     '};'
                 ]
             }),

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

@@ -36,9 +36,12 @@ mod library {
         where
             nanocom::CObject<Self>: Ex,
         {
-            const INTERFACE: Interface = Interface {
-                A: Self::A,
-                B: Self::B,
+            const VMT: Vmt = Vmt {
+                iunknown: Self::IUNKNOWN,
+                interface: Interface {
+                    A: Self::A,
+                    B: Self::B,
+                }
             };
         }
 
@@ -73,10 +76,7 @@ mod number {
     impl nanocom::Class for X {
         type Interface = IMy::Interface;
         fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: IMy::Vmt = Vmt {
-                iunknown: X::IUNKNOWN,
-                interface: X::INTERFACE,
-            };
+            static V: IMy::Vmt = X::VMT;
             &V
         }
     }
@@ -142,10 +142,7 @@ mod destructor {
     impl nanocom::Class for X {
         type Interface = IMy::Interface;
         fn static_vmt() -> &'static Vmt<Self::Interface> {
-            static V: IMy::Vmt = Vmt {
-                iunknown: X::IUNKNOWN,
-                interface: X::INTERFACE,
-            };
+            static V: IMy::Vmt = X::VMT;
             &V
         }
     }

package/com/rust/test.f.cjs

@@ -66,14 +66,17 @@ module.exports = () => {
         '        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' +
-        '            SetManagedStruct: Self::SetManagedStruct,\n' +
+        '        const VMT: Vmt = Vmt {\n' +
+        '            iunknown: Self::IUNKNOWN,\n' +
+        '            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' +
+        '                SetManagedStruct: Self::SetManagedStruct,\n' +
+        '            },\n' +
         '        };\n' +
         '    }\n' +
         '    impl<T> ClassEx for T\n' +

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

@@ -1 +1,43 @@
+use crate::_result::IMy::ClassEx;
+
 mod _result;
+
+struct My {}
+
+impl nanocom::Class for My {
+    type Interface = _result::IMy::Interface;
+    fn static_vmt() -> &'static _result::IMy::Vmt {
+        static VMT: _result::IMy::Vmt = My::VMT;
+        &VMT
+    }
+}
+
+impl _result::IMy::Ex for nanocom::CObject<My> {
+    fn GetSlice(&self) -> _result::Slice {
+        todo!()
+    }
+
+    fn SetSlice(&self, slice: _result::Slice) {
+        todo!()
+    }
+
+    fn GetUnsafe(&self) -> *const bool {
+        todo!()
+    }
+
+    fn SetUnsafe(&self, p: *const _result::Slice, size: u32) {
+        todo!()
+    }
+
+    fn Some(&self, p: &_result::IMy::Object) -> bool {
+        todo!()
+    }
+
+    fn GetIMy(&self) -> _result::IMy::Ref {
+        todo!()
+    }
+
+    fn SetManagedStruct(&self, a: _result::ManagedStruct) {
+        todo!()
+    }
+}

package/package.json

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

package/types/range_map/module.f.cjs

@@ -0,0 +1,60 @@
+const sortedList = require("../sorted_list/module.f.cjs")
+const { genericMerge } = sortedList
+const list = require("../list/module.f.cjs")
+const option = require("../option/module.f.cjs")
+const { cmp } = require('../number/module.f.cjs')
+const operator = require("../function/operator/module.f.cjs")
+
+/**
+ * @template T
+ * @typedef {[T, number]} Entry
+ */
+
+/**
+ * @template T
+ * @typedef {sortedList.SortedList<Entry<T>>} RangeMap
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly union: operator.Reduce<T>
+ *  readonly equal: operator.Equal<T>
+  * }} Operators
+ */
+
+/**
+ * @template T
+ * @typedef {option.Option<Entry<T>>} RangeState
+ */
+
+/**
+ * @template T
+ * @typedef {(a: RangeMap<T>) => (b: RangeMap<T>) => RangeMap<T>} RangeMerge
+ */
+
+/** @type {<T>(union: operator.Reduce<T>) => (equal: operator.Equal<T>) => sortedList.ReduceOp<Entry<T>, RangeState<T>>} */
+const reduceOp = union => equal => state => ([aItem, aMax]) => ([bItem, bMax])  => {
+  const sign = cmp(aMax)(bMax)
+  const min = sign === 1 ? bMax : aMax
+  const u = union(aItem)(bItem)
+  const newState = state !== undefined && equal(state[0])(u) ? undefined : state
+  return [newState, sign, [u, min]]
+}
+
+/** @type {<T>(equal: operator.Equal<T>) => sortedList.TailReduce<Entry<T>, RangeState<T>>} */
+const tailReduce = equal => state => tail => {
+  if (state === undefined) { return tail }
+  const tailResult = list.next(tail)
+  if (tailResult === undefined) { return [state] }
+  if (equal(state[0])(tailResult.first[0])) { return tailResult }
+  return { first: state, tail: tailResult }
+}
+
+ /** @type {<T>(op: Operators<T>) => RangeMerge<T>} */
+const merge = ({union, equal}) => genericMerge({reduceOp: reduceOp(union)(equal), tailReduce: tailReduce(equal)})(undefined)
+
+module.exports = {
+    /** @readonly */
+    merge
+}

package/types/range_map/test.f.cjs

@@ -0,0 +1,81 @@
+const _ = require('./module.f.cjs')
+const { unsafeCmp } = require('../function/compare/module.f.cjs')
+const json = require('../../json/module.f.cjs')
+const { sort } = require('../../types/object/module.f.cjs')
+const sortedSet = require('../sorted_set/module.f.cjs')
+const { list } = require('../module.f.cjs')
+const operator = require("../function/operator/module.f.cjs")
+
+/** @type {(a: readonly json.Unknown[]) => string} */
+const stringify = a => json.stringify(sort)(a)
+
+/** @type {_.Operators<sortedSet.SortedSet<string>>} */
+const op = { union: sortedSet.union(unsafeCmp), equal: list.equal(operator.strictEqual) }
+
+module.exports = {
+    merge: [
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = undefined
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = undefined
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 1], [['b'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['c'], 3]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['d'], 4]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],1],[["b","c"],2],[["c","d"],3],[["d"],4]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['d'], 4]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 2], [['c'], 3]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],1],[["b","d"],2],[["c","d"],3],[["d"],4]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['b'], 1], [['a'], 2]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a","b"],2]]') { throw result }
+        },
+        () => {
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const a = [[['a'], 1], [['b'], 2], [['a'], 3]]
+            /** @type {_.RangeMap<sortedSet.SortedSet<string>>} */
+            const b = [[['a'], 5]]
+            const merged = _.merge(op)(a)(b)
+            const result = stringify(list.toArray(merged))
+            if (result !== '[[["a"],1],[["a","b"],2],[["a"],5]]') { throw result }
+        }
+    ]
+}

package/types/sorted_list/module.f.cjs

@@ -14,11 +14,6 @@ const { identity } = require('../function/module.f.cjs')
  * @typedef {(a: T) => (b: T) => compare.Sign} Cmp
  */
 
-/**
- * @template T
- * @typedef {SortedList<[T, number]>} RangeMap
- */
-
 /**
  * @template T
  * @template S
@@ -51,7 +46,7 @@ const genericMerge = reduce => {
         const aResult = next(a)
         if (aResult === undefined) { return tailReduce(state)(b) }
         const bResult = next(b)
-        if (bResult === undefined) { return tailReduce(state)(a) }
+        if (bResult === undefined) { return tailReduce(state)(aResult) }
         const [first, sign, stateNext] = reduceOp(state)(aResult.first)(bResult.first)
         const aNext = sign === 1 ? a : aResult.tail
         const bNext = sign === -1 ? b : bResult.tail