functionalscript 0.0.198 → 0.0.203

package/btree/index.js

@@ -1,4 +1,5 @@
-const { index3, index5 } = require('../cmp')
+const cmp = require('../cmp')
+const { index3, index5 } = cmp
 const seq = require('../sequence')
 
 /**
@@ -8,29 +9,29 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {import('../cmp').Cmp<T>} Cmp
+ * @typedef {cmp.Cmp<T>} Cmp
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array1<T>} Array1
+ * @typedef {readonly[T]} Array1
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array2<T>} Array2
+ * @typedef {readonly[T,T]} Array2
  */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array3<T>} Array3
+ * @typedef {readonly[T,T,T]} Array3
  */
 
-/** @typedef {import('../sequence/array').Index2} Index2 */
+/** @typedef {0|1} Index2 */
 
-/** @typedef {import('../sequence/array').Index3} Index3 */
+/** @typedef {0|1|2} Index3 */
 
-/** @typedef {import('../sequence/array').Index5} Index5 */
+/** @typedef {0|1|2|3|4} Index5 */
 
 //
 
@@ -59,14 +60,11 @@ const seq = require('../sequence')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
-/** @typedef {{ readonly done: false }} NotFoundDone */
+/** @typedef {readonly['done']} NotFoundDone */
 
 /** 
  * @template T
- * @typedef {{ 
- *  readonly done: true 
- *  readonly value: T 
- * }} FoundDone 
+ * @typedef {readonly['done', T]} FoundDone 
  */
 
 /**
@@ -76,12 +74,12 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {{ readonly replace: Node<T> }} Replace
+ * @typedef {readonly['replace', Node<T>]} Replace
  */
 
 /**
  * @template T
- * @typedef {{ readonly overflow: Branch3<T> }} Overflow
+ * @typedef {readonly['overflow', Branch3<T>]} Overflow
  */
 
 /**
@@ -137,9 +135,11 @@ const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
  *  Result<T>} 
  */
 const merge = overflow => replace => result => {
-    if ('done' in result) { return result }
-    if ('replace' in result) { return { replace: replace(result.replace) } }
-    return overflow(result.overflow)
+    switch (result[0]) {
+        case 'done': { return result }
+        case 'replace': { return ['replace', replace(result[1])] }
+        default: { return overflow(result[1]) }
+    }
 }
 
 /** 
@@ -148,7 +148,7 @@ const merge = overflow => replace => result => {
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge2 = overflow => merge(o => ({ replace: overflow(o) }))
+const merge2 = overflow => merge(o => ['replace', overflow(o)])
 
 /** 
  * @type {<T>(overflow: (o: Branch3<T>) => Branch7<T>) => 
@@ -156,7 +156,7 @@ const merge2 = overflow => merge(o => ({ replace: overflow(o) }))
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
-const merge3 = overflow => merge(o => ({ overflow: split(overflow(o)) }))
+const merge3 = overflow => merge(o => ['overflow', split(overflow(o))])
 
 /** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
 const visit = ({ found, notFound }) => cmp => {
@@ -233,7 +233,7 @@ const visit = ({ found, notFound }) => cmp => {
 }
 
 /** @type { <T>(_: T) => Done<T> } */
-const found = value => ({ done: true, value })
+const found = value => ['done', value]
 
 /** @type {Found} */
 const foundGet = {
@@ -245,7 +245,7 @@ const foundGet = {
     branch5_right: () => ([, , , value]) => found(value),
 }
 /** @type { () => () => NotFoundDone } */
-const notFound = () => () => ({ done: false })
+const notFound = () => () => ['done']
 
 /** @type {NotFound} */
 const notFoundGet = {
@@ -257,7 +257,7 @@ const notFoundGet = {
 }
 
 /** @type { <T>(_: Node<T>) => Replace<T> } */
-const replace = node => ({ replace: node })
+const replace = node => ['replace', node]
 
 /** @type {Found} */
 const foundReplace = {
@@ -270,7 +270,7 @@ const foundReplace = {
 }
 
 /** @type {<T>(leaf3: Array3<T>) => Result<T>} */
-const overflow = ([v0, v1, v2]) => ({ overflow: [[v0], v1, [v2]] })
+const overflow = ([v0, v1, v2]) => ['overflow', [[v0], v1, [v2]]]
 
 /** @type {NotFound} */
 const notFoundInsert = {
@@ -339,8 +339,8 @@ module.exports = {
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
-        const _0 = visit(getVisitor)(cmp)(() => { throw '' })(node)
-        if ('done' in _0 && _0.done) { return _0.value }
+        const result = visit(getVisitor)(cmp)(() => { throw '' })(node)
+        if (result[0] === 'done') { return result[1] }
         return undefined
     },
     /** @readonly */

package/btree/test.js

@@ -1,14 +1,15 @@
 const btree = require('.')
-const { setVisitor, values: valuesList } = btree
+const { setVisitor, values } = btree
 const { cmp } = require('../cmp') 
 const list = require('../sequence')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
     const result = setVisitor(cmp(value))(() => value)(node)
-    if ('replace' in result) { return result.replace }
-    if ('overflow' in result) { return result.overflow }
-    return node
+    switch (result[0]) {
+        case 'replace': case 'overflow': { return result[1] }
+        default: { return node }
+    }
 }
 
 const test = () => {
@@ -22,7 +23,7 @@ const test = () => {
     //
     {
         /** @type {import('../sequence').Result<string>} */
-        let _item = list.next(valuesList(_map))
+        let _item = list.next(values(_map))
         while (_item !== undefined) {
             _item = list.next(_item[1])
         }

package/map/index.js

@@ -43,10 +43,11 @@ const keyCmp = a => ([b]) => cmp(a)(b)
 const create = root => ({
     get: name => option.map(([,value]) => value)(getVisitor(keyCmp(name))(root)),
     set: name => value => {
-        const _0 = setVisitor(keyCmp(name))(() => [name, value])(root)
-        if ('replace' in _0) { return create(_0.replace) }
-        if ('overflow' in _0) { return create(_0.overflow) }
-        throw ''
+        const result = setVisitor(keyCmp(name))(() => [name, value])(root)
+        switch (result[0]) {
+            case 'replace': case 'overflow': { return create(result[1]) }
+            default: { throw '' }
+        }
     },
     entries: values(root),
     root,

package/module-manager/README.md

@@ -0,0 +1,30 @@
+# Module Manager
+
+## Module Provider
+
+```js
+/** @typedef {(packageName: string) => PackageMap|Package|undefined} PackageMap */
+
+/**
+ * @typedef {{
+ *  readonly id: string,
+ *  readonly packages: PackageMap,
+ *  readonly files: (fileName: string) => string|undefined,
+ * }} Package
+ */
+```
+
+## Runner IO
+
+```js
+/** 
+ * @typedef {(require: Require<T>) => (info: T) => (source: string) => readonly[Result<unknown, Error>, T]} RunnerIo
+ */
+```
+
+```js
+/**
+ * @template T
+ * @typedef {(info: T) => (module: string) => readonly[Result<unknown, Error>, T]} Require<T>
+ */
+```

package/module-manager/node/test.js

@@ -1,7 +1,7 @@
 const mm = require('..')
 const i = require('.')
 
-/** @type {{ [_ in string]: string}} */
+/** @type {{ readonly [_ in string]: string}} */
 const files = {
     'index.js': './index.js',
     'a/index.js': './a/index.js',

package/module-manager/test.js

@@ -31,7 +31,7 @@ if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { thro
     const c = { 
         dependencies: () => undefined,
         file: path => {
-            /** @type {{ [_ in string]?: string}} */
+            /** @type {{ readonly [_ in string]?: string}} */
             const f = {
                 'index.js': 'b/c ./index.js',
                 'x/index.js': 'b/c ./x/index.js',
@@ -41,11 +41,11 @@ if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { thro
         },
         id: ['c']
     }
-    /** @type {{ [_ in string]: i.Package|i.Dependencies}} */
+    /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
     const packages = {
         a,
         b: s => {
-            /** @type {{ [_ in string]: i.Package|i.Dependencies}} */
+            /** @type {{ readonly [_ in string]: i.Package|i.Dependencies}} */
             const p = { c }
             return p[s]
         }
@@ -54,7 +54,7 @@ if (cast(i.pathNorm('./a/../b/c/..//d/'.split('/'))).join('/') !== 'b/d') { thro
     const pack = {
         dependencies: s => packages[s],
         file: path => {
-            /** @type {{ [_ in string]?: string}} */
+            /** @type {{ readonly [_ in string]?: string}} */
             const f = {
                 'index.js': './index.js',
                 'index/index.js': './index/index.js',

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "functionalscript",
-   "version": "0.0.198",
+   "version": "0.0.203",
    "description": "FunctionalScript is a functional subset of JavaScript",
    "main": "index.js",
    "scripts": {

package/test.js

@@ -59,3 +59,51 @@ const assert_if = c => { if (c) { throw 'assert_if' } }
             v.commit !== '4b14a7a2b11cf53f037931eb7bef240f96dcea64'),
         assert)
 }
+
+{
+    const c = (()=>{})['constructor']
+    const f = c('return 5')
+    const result = f()
+    if (result !== 5) { throw 'function' }
+}
+
+{
+    /** @type {any} */
+    const o = {}
+    const c = o['constructor']
+    // console.log(c)
+    // console.log(c(()=>{}))
+}
+
+{
+    /** @type {any} */
+    const o = {
+        constructor: undefined
+    }
+    const c = o['constructor']
+    console.log(c)
+}
+
+{
+    /** @type {any} */
+    const b = '42'
+    const r = Number(b)
+    console.log(r)
+}
+
+{
+    /** @type {any} */
+    const o = {}
+    //const c = o['constructor']
+    //const c = o['__proto__']
+    //const c = o['__defineGetter__']
+    //const c = o['__defineSetter__']
+    //const c = o['__lookupGetter__']
+    //const c = o['__lookupSetter__'] 
+    //const c = o['hasOwnProperty']   
+    //const c = o['isPrototypeOf']
+    //const c = o['propertyIsEnumerable']
+    //const c = o['toString']
+    const c = o['valueOf']
+    console.log(c)
+}