functionalscript 0.0.427 → 0.0.429

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')
@@ -47,6 +47,83 @@ const mapAssign = map(assign)
 
 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 => {
 
@@ -134,38 +211,34 @@ const rust = library => {
         return [
             `pub mod ${name} {`,
             [
-                'pub type Object = nanocom::Object<Interface>;',
-                'pub type Ref = nanocom::Ref<Interface>;',
-                'pub type Vmt = nanocom::Vmt<Interface>;',
+                rustType('Object'),
+                rustType('Ref'),
+                rustType('Vmt'),
             ],
             rustStruct(mapVirtualFn(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 {`,
+            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 {}',
-                'trait PrivateClassEx: nanocom::Class<Interface = Interface>',
-                'where',
-                [   'nanocom::CObject<Self>: Ex'],
-                `{`,
-                flatMapImpl(e),
-                `}`,
-                'impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}',
-            ],
+                ]
+            }),
+            traitImpl({
+                type: 'PrivateClassEx',
+                content: flatMapImpl(e)
+            }),
             '}'
         ]
     }

package/com/rust/test.f.cjs

@@ -57,8 +57,9 @@ module.exports = {
             '            unsafe { (self.interface().GetIMy)(self) }\n' +
             '        }\n' +
             '    }\n' +
-            '    pub trait ClassEx: nanocom::Class<Interface = Interface>\n' +
+            '    pub trait ClassEx\n' +
             '    where\n' +
+            '        Self: nanocom::Class<Interface = Interface>,\n' +
             '        nanocom::CObject<Self>: Ex,\n' +
             '    {\n' +
             '        const INTERFACE: Interface = Interface {\n' +
@@ -70,10 +71,16 @@ module.exports = {
             '            GetIMy: Self::GetIMy,\n' +
             '        };\n' +
             '    }\n' +
-            '    impl<T: nanocom::Class<Interface = Interface>> ClassEx for T where nanocom::CObject<T>: Ex {}\n' +
-            '    trait PrivateClassEx: nanocom::Class<Interface = Interface>\n' +
+            '    impl<T> ClassEx for T\n' +
             '    where\n' +
-            '        nanocom::CObject<Self>: Ex\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' +
@@ -94,7 +101,12 @@ module.exports = {
             '            unsafe { Self::to_cobject(this) }.GetIMy()\n' +
             '        }\n' +
             '    }\n' +
-            '    impl<T: nanocom::Class<Interface = Interface>> PrivateClassEx for T where nanocom::CObject<T>: Ex {}\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] }

package/commonjs/build/module.f.cjs

@@ -8,7 +8,7 @@ const object = require('../../types/object/module.f.cjs')
 const { fromMap } = object
 const path = require('../path/module.f.cjs')
 const { parseAndFind } = path
-const stringSet = require('../../types/stringset/module.f.cjs')
+const stringSet = require('../../types/string_set/module.f.cjs')
 const { set: setSet, contains: setContains } = stringSet
 
 /**

package/fsm/README.md

@@ -0,0 +1,4 @@
+# FSM
+
+This module is about a [finite-state machine](https://en.wikipedia.org/wiki/Finite-state_machine). It's not about
+[Flying Spaghetti Monster](https://en.wikipedia.org/wiki/Flying_Spaghetti_Monster).

package/fsm/module.f.cjs

@@ -0,0 +1,28 @@
+const { todo } = require('../dev/module.f.cjs')
+const list = require('../types/list/module.f.cjs')
+const byteSet = require('../types/byte_set/module.f.cjs')
+
+/** @typedef {readonly[string, byteSet.ByteSet, string]} Rule */
+
+/** @typedef {list.List<Rule>} Grammar */
+
+/** @typedef {readonly string[]} ByteMap */
+
+/**
+ * @typedef {{
+ *  readonly[state in string]: ByteMap
+ * }} Dfa
+ */
+
+/** @type {(faId: string) => string} */
+const escape = faId => todo()
+
+/** @type {(grammar: Grammar) => Dfa} */
+const dfa = grammar => todo()
+
+module.exports = {
+    /** @readonly */
+    escape,
+    /** @readonly */
+    dfa,
+}

package/package.json

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

package/types/byte_set/module.f.cjs

@@ -0,0 +1,57 @@
+const { fn } = require('../function/module.f.cjs')
+
+/** @typedef {bigint} ByteSet */
+/** @typedef {number} Byte */
+
+/** @type {(n: Byte) => (s: ByteSet) => boolean} */
+const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
+
+// create a set
+
+const empty = 0n
+
+/** @type {(n: Byte) => ByteSet} */
+const one = n => 1n << BigInt(n)
+
+/** @type {(r: readonly[Byte, Byte]) => ByteSet} */
+const range = ([b, e]) => one(e - b + 1) - 1n << BigInt(b)
+
+// set operations
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const union = a => b => a | b
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const intersect = a => b => a & b
+
+/** @type {(a: ByteSet) => (b: ByteSet) => ByteSet} */
+const difference = a => b => intersect(a)(complement(b))
+
+/** @type {(n: ByteSet) => ByteSet} */
+const complement = n => ~n
+
+// additional operations
+
+const set = fn(one).then(union).result
+
+const setRange = fn(range).then(union).result
+
+/** @type {(n: Byte) => (s: ByteSet) => ByteSet} */
+const unset = n => s => difference(s)(one(n))
+
+module.exports = {
+    /** @readonly */
+    empty,
+    /** @readonly */
+    has,
+    /** @readonly */
+    set,
+    /** @readonly */
+    unset,
+    /** @readonly */
+    union,
+    /** @readonly */
+    setRange,
+    /** @readonly */
+    range,
+}

package/types/module.f.cjs

@@ -10,13 +10,15 @@ module.exports = {
     /** @readonly */
     map: require('./map/module.f.cjs'),
     /** @readonly */
+    nibbleSet: require('./nibble_set/module.f.cjs'),
+    /** @readonly */
     object: require('./object/module.f.cjs'),
     /** @readonly */
     range: require('./range/module.f.cjs'),
     /** @readonly */
     result: require('./result/module.f.cjs'),
     /** @readonly */
-    stringset: require('./stringset/module.f.cjs'),
+    stringSet: require('./string_set/module.f.cjs'),
     /** @readonly */
     bigint: require('./bigint/module.f.cjs'),
     /** @readonly */

package/types/byteSet/module.f.cjs

@@ -1,30 +0,0 @@
-/** @typedef {bigint} byteSet */
-/** @typedef {number} byte */
-
-/** @type {(n: byte) => (s: byteSet) => boolean} */
-const has = n => s => ((s >> BigInt(n)) & 1n) === 1n
-
-/** @type {(n: byte) => (s: byteSet) => byteSet} */
-const set = n => s => s | (1n << BigInt(n))
-
-/** @type {(n: byte) => (s: byteSet) => byteSet} */
-const unset = n => s => s & ~(1n << BigInt(n))
-
-/** @type {(r: readonly[number, number]) => (s: byteSet) => byteSet} */
- const setRange = ([b, e]) => s => s | ((1n << BigInt(e - b + 1)) - 1n << BigInt(b))
-
-// how to define FA???
-// const stateA = [init, set] ????
-
-module.exports = {
-    /** @readonly */
-    empty: 0n,
-    /** @readonly */
-    has,
-    /** @readonly */
-    set,
-    /** @readonly */
-    unset,
-    /** @readonly */
-    setRange
-}