functionalscript 0.0.278 → 0.0.279

package/package.json

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

package/types/btree/index.js

@@ -1,3 +1,4 @@
+const { todo } = require('../../dev')
 const cmp = require('../function/compare')
 const { index3, index5 } = cmp
 const seq = require('../list')
@@ -87,10 +88,10 @@ const seq = require('../list')
  * @typedef { Done<T> | Replace<T> | Overflow<T> } Result
  */
 
-/** @typedef {<T>(_: Lazy<T>) => (_: Leaf1<T>) => Result<T>} InLeaf1 */
-/** @typedef {<T>(_: Lazy<T>) => (_: Leaf2<T>) => Result<T>} InLeaf2 */
-/** @typedef {<T>(_: Lazy<T>) => (_: Branch3<T>) => Result<T>} InBranch3 */
-/** @typedef {<T>(_: Lazy<T>) => (_: Branch5<T>) => Result<T>} InBranch5 */
+/** @typedef {<T>(_: Leaf1<T>) => LazyResult<T>} InLeaf1 */
+/** @typedef {<T>(_: Leaf2<T>) => LazyResult<T>} InLeaf2 */
+/** @typedef {<T>(_: Branch3<T>) => LazyResult<T>} InBranch3 */
+/** @typedef {<T>(_: Branch5<T>) => LazyResult<T>} InBranch5 */
 
 /**
  * @typedef {{
@@ -113,6 +114,21 @@ const seq = require('../list')
  * }} NotFound
  */
 
+/**
+ * @template T
+ * @typedef {(f: (_: Node<T>) => LazyResult<T>) => LazyResult<T>} FResult<T>
+ */
+
+/**
+ * @typedef {{
+ *  readonly branch3_left: <T>(branch3: Branch3<T>) => FResult<T>
+ *  readonly branch3_right: <T>(branch3: Branch3<T>) => FResult<T>
+ *  readonly branch5_left: <T>(branch5: Branch5<T>) => FResult<T>
+ *  readonly branch5_middle: <T>(branch5: Branch5<T>) => FResult<T>
+ *  readonly branch5_right: <T>(branch5: Branch5<T>) => FResult<T>
+ * }} Continue
+ */
+
 /**
  * @typedef {{
  *  readonly found: Found
@@ -128,13 +144,19 @@ const seq = require('../list')
 /** @type {<T>(n: Branch7<T>) => Branch3<T>} */
 const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
 
+/**
+ * @template T
+ * @typedef {(init: Lazy<T>) => Result<T>} LazyResult
+ */
+
 /**
  * @type {<T>(extend: (o: Branch3<T>) => Result<T>) =>
  *  (replace: (r: Node<T>) => Node<T>) =>
- *  (result: Result<T>) =>
- *  Result<T>}
+ *  (result: LazyResult<T>) =>
+ *  LazyResult<T>}
  */
-const merge = extend => replace => result => {
+const merge = extend => replace => lazyResult => init => {
+    const result = lazyResult(init)
     switch (result[0]) {
         case 'done': { return result }
         case 'replace': { return ['replace', replace(result[1])] }
@@ -142,7 +164,7 @@ const merge = extend => replace => result => {
     }
 }
 
-/** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
+/** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (node: Node<T>) => LazyResult<T>} */
 const visit = ({ found, notFound }) => cmp => {
     const i3 = index3(cmp)
     const i5 = index5(cmp)
@@ -150,84 +172,82 @@ const visit = ({ found, notFound }) => cmp => {
     /**
      * @type {(extend: (o: Branch3<T>) => Branch5<T>) =>
      *  (replace: (r: Node<T>) => Branch3<T>) =>
-     *  (result: Result<T>) =>
-     *  Result<T>}
+     *  (result: LazyResult<T>) =>
+     *  LazyResult<T>}
      */
     const merge2 = extend => merge(o => ['replace', extend(o)])
     /**
      * @type {(extend: (o: Branch3<T>) => Branch7<T>) =>
      *  (replace: (r: Node<T>) => Branch5<T>) =>
-     *  (result: Result<T>) =>
-     *  Result<T>}
+     *  (result: LazyResult<T>) =>
+     *  LazyResult<T>}
      */
     const merge3 = extend => merge(o => ['overflow', split(extend(o))])
-    return init => {
-        /** @type {(node: Node<T>) => Result<T>} */
-        const f = node => {
-            switch (node.length) {
-                case 1: {
-                    switch (i3(node[0])) {
-                        case 0: { return notFound.leaf1_left(init)(node) }
-                        case 1: { return found.leaf1(init)(node) }
-                        default: { return notFound.leaf1_right(init)(node) }
-                    }
+    /** @type {(node: Node<T>) => LazyResult<T>} */
+    const f = node => {
+        switch (node.length) {
+            case 1: {
+                switch (i3(node[0])) {
+                    case 0: { return notFound.leaf1_left(node) }
+                    case 1: { return found.leaf1(node) }
+                    default: { return notFound.leaf1_right(node) }
                 }
-                case 2: {
-                    switch (i5(node)) {
-                        case 0: { return notFound.leaf2_left(init)(node) }
-                        case 1: { return found.leaf2_left(init)(node) }
-                        case 2: { return notFound.leaf2_middle(init)(node) }
-                        case 3: { return found.leaf2_right(init)(node) }
-                        default: { return notFound.leaf2_right(init)(node) }
-                    }
+            }
+            case 2: {
+                switch (i5(node)) {
+                    case 0: { return notFound.leaf2_left(node) }
+                    case 1: { return found.leaf2_left(node) }
+                    case 2: { return notFound.leaf2_middle(node) }
+                    case 3: { return found.leaf2_right(node) }
+                    default: { return notFound.leaf2_right(node) }
                 }
-                case 3: {
-                    const [n0, v1, n2] = node
-                    switch (i3(v1)) {
-                        case 0: {
-                            return merge2
-                                (e => [...e, v1, n2])
-                                (r => [r, v1, n2])
-                                (f(n0))
-                        }
-                        case 1: { return found.branch3(init)(node) }
-                        default: {
-                            return merge2
-                                (e => [n0, v1, ...e])
-                                (r => [n0, v1, r])
-                                (f(n2))
-                        }
+            }
+            case 3: {
+                const [n0, v1, n2] = node
+                switch (i3(v1)) {
+                    case 0: {
+                        return merge2
+                            (e => [...e, v1, n2])
+                            (r => [r, v1, n2])
+                            (f(n0))
+                    }
+                    case 1: { return found.branch3(node) }
+                    default: {
+                        return merge2
+                            (e => [n0, v1, ...e])
+                            (r => [n0, v1, r])
+                            (f(n2))
                     }
                 }
-                default: {
-                    const [n0, v1, n2, v3, n4] = node
-                    switch (i5([v1, v3])) {
-                        case 0: {
-                            return merge3
-                                (o => [...o, v1, n2, v3, n4])
-                                (r => [r, v1, n2, v3, n4])
-                                (f(n0))
-                        }
-                        case 1: { return found.branch5_left(init)(node) }
-                        case 2: {
-                            return merge3
-                                (o => [n0, v1, ...o, v3, n4])
-                                (r => [n0, v1, r, v3, n4])
-                                (f(n2))
-                        }
-                        case 3: { return found.branch5_right(init)(node) }
-                        default: {
-                            return merge3
-                                (o => [n0, v1, n2, v3, ...o])
-                                (r => [n0, v1, n2, v3, r])
-                                (f(n4))
-                        }
+            }
+            default: {
+                const [n0, v1, n2, v3, n4] = node
+                switch (i5([v1, v3])) {
+                    case 0: {
+                        return merge3
+                            (o => [...o, v1, n2, v3, n4])
+                            (r => [r, v1, n2, v3, n4])
+                            (f(n0))
+                    }
+                    case 1: { return found.branch5_left(node) }
+                    case 2: {
+                        return merge3
+                            (o => [n0, v1, ...o, v3, n4])
+                            (r => [n0, v1, r, v3, n4])
+                            (f(n2))
+                    }
+                    case 3: { return found.branch5_right(node) }
+                    default: {
+                        return merge3
+                            (o => [n0, v1, n2, v3, ...o])
+                            (r => [n0, v1, n2, v3, r])
+                            (f(n4))
                     }
                 }
             }
         }
-        return f
     }
+    return f
 }
 
 /** @type { <T>(_: T) => Done<T> } */
@@ -235,12 +255,12 @@ const found = value => ['done', value]
 
 /** @type {Found} */
 const foundGet = {
-    leaf1: () => ([value]) => found(value),
-    leaf2_left: () => ([value]) => found(value),
-    leaf2_right: () => ([, value]) => found(value),
-    branch3: () => ([, value]) => found(value),
-    branch5_left: () => ([, value]) => found(value),
-    branch5_right: () => ([, , , value]) => found(value),
+    leaf1: ([value]) => () => found(value),
+    leaf2_left: ([value]) => () => found(value),
+    leaf2_right: ([, value]) => () => found(value),
+    branch3: ([, value]) => () => found(value),
+    branch5_left: ([, value]) => () => found(value),
+    branch5_right: ([, , , value]) => () => found(value),
 }
 /** @type { () => () => NotFoundDone } */
 const notFound = () => () => ['done']
@@ -259,12 +279,12 @@ const replace = node => ['replace', node]
 
 /** @type {Found} */
 const foundReplace = {
-    leaf1: f => () => replace([f()]),
-    leaf2_left: f => ([, v1]) => replace([f(), v1]),
-    leaf2_right: f => ([v0,]) => replace([v0, f()]),
-    branch3: f => ([n0, , n2]) => replace([n0, f(), n2]),
-    branch5_left: f => ([n0, , n2, v3, n4]) => replace([n0, f(), n2, v3, n4]),
-    branch5_right: f => ([n0, v1, n2, , n4]) => replace([n0, v1, n2, f(), n4])
+    leaf1: () => f => replace([f()]),
+    leaf2_left: ([, v1]) => f => replace([f(), v1]),
+    leaf2_right: ([v0,]) => f => replace([v0, f()]),
+    branch3: ([n0, , n2]) => f => replace([n0, f(), n2]),
+    branch5_left: ([n0, , n2, v3, n4]) => f => replace([n0, f(), n2, v3, n4]),
+    branch5_right: ([n0, v1, n2, , n4]) => f => replace([n0, v1, n2, f(), n4])
 }
 
 /** @type {<T>(leaf3: Array3<T>) => Result<T>} */
@@ -272,11 +292,11 @@ const overflow = ([v0, v1, v2]) => ['overflow', [[v0], v1, [v2]]]
 
 /** @type {NotFound} */
 const notFoundInsert = {
-    leaf1_left: f => ([v]) => replace([f(), v]),
-    leaf1_right: f => ([v]) => replace([v, f()]),
-    leaf2_left: f => ([v0, v1]) => overflow([f(), v0, v1]),
-    leaf2_middle: f => ([v0, v1]) => overflow([v0, f(), v1]),
-    leaf2_right: f => ([v0, v1]) => overflow([v0, v1, f()]),
+    leaf1_left: ([v]) => f => replace([f(), v]),
+    leaf1_right: ([v]) => f => replace([v, f()]),
+    leaf2_left: ([v0, v1]) => f => overflow([f(), v0, v1]),
+    leaf2_middle: ([v0, v1]) => f => overflow([v0, f(), v1]),
+    leaf2_right: ([v0, v1]) => f => overflow([v0, v1, f()]),
 }
 
 /** @type {Visitor} */
@@ -303,7 +323,7 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(node: Node<T>) => seq.List<T>} */
+/** @type {<T>(node: Node<T>) => seq.Thunk<T>} */
 const values = node => () => {
     switch (node.length) {
         case 1: case 2: { return node }
@@ -334,9 +354,9 @@ module.exports = {
      * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
-        const result = visit(getVisitor)(cmp)(() => { throw 'getVisitor' })(node)
-        if (result[0] === 'done') { return result[1] }
-        return undefined
+        const result = visit(getVisitor)(cmp)(node)(() => { throw 'getVisitor' })
+        if (result[0] !== 'done') { throw 'getVisitor result' }
+        return result[1]
     },
     /** @readonly */
     setVisitor: visit(setVisitor),

package/types/btree/test.js

@@ -1,11 +1,11 @@
 const btree = require('.')
 const { setVisitor, values } = btree
-const { cmp } = require('../function/compare') 
+const { cmp } = require('../function/compare')
 const list = require('../list')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
-    const result = setVisitor(cmp(value))(() => value)(node)
+    const result = setVisitor(cmp(value))(node)(() => value)
     switch (result[0]) {
         case 'replace': case 'overflow': { return result[1] }
         default: { return node }

package/types/map/index.js

@@ -47,7 +47,7 @@ const set = name => value => map =>  {
     /** @type {Entry<typeof value>} */
     const entry = [name, value]
     if (map === undefined) { return [entry] }
-    const result = setVisitor(keyCmp(name))(() => entry)(map)
+    const result = setVisitor(keyCmp(name))(map)(() => entry)
     switch (result[0]) {
         case 'replace': case 'overflow': { return result[1] }
         default: { throw 'invalid BTree operation' }