functionalscript 0.0.281 → 0.0.282

package/package.json

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

package/types/btree/README.md

@@ -2,7 +2,7 @@
 
 https://en.wikipedia.org/wiki/B-tree
 
-## BTree 2-3 nodes 
+## BTree 2-3 nodes
 
 `Node<T>`:
 
@@ -66,7 +66,7 @@ Posible actions:
 |left  |    0|`[(L VM R) v1 n2]`  |
 |right |    2|`[n0 v1 (L VM R)]`  |
 
-## Branch5 Overflow 
+## Branch5 Overflow
 
 - current `[n0, v1, n2, v3, n4]`
 - overflow `[L, VM, R]`
@@ -76,3 +76,56 @@ Posible actions:
 |left  |    0|`[...o v1 n2 v3 n4]`|`[(L VM R) v1 n2 v3 n4]`|`[[ L VM R ] v1 [n2 v3 n4]]`|
 |middle|    2|`[n0 v1 ...o v3 n4]`|`[n0 v1 (L VM R) v3 n4]`|`[[n0 v1 L ] VM [ R v3 n4]]`|
 |right |    4|`[n0 v1 n2 v3 ...o]`|`[n0 v1 n2 v3 (L VM R)]`|`[[n0 v1 n2] v3 [ L VM R ]]`|
+
+## Deleting a Node
+
+|type              |index|                     |        |                             |
+|------------------|-----|---------------------|--------|-----------------------------|
+|`[v]`             |    0|                     |        |underflow `undefined`        |
+|`[v0,v1]`         |    0|                     |        |replace `[v1]`               |
+|                  |    1|                     |        |replace `[v0]`               |
+|`[n0,v1,n2]`      |    1|`concat(n0,n2)`      |overflow|replace `[n0_,v1_,n1_]`      |
+|                  |     |                     |replace |underflow `n_`               |
+|`[n0,v1,n2,v3,n4]`|    1|`concat(n0,n2),v3,n4`|overflow|replace `[n0_,v1_,n1_,v3,n4]`|
+|                  |     |                     |replace |replace `[n_,v3,n4]`         |
+|                  |    3|`n0,v1,concat(n2,n4)`|overflow|replace `[n0,v1,n0_,v1_,n1_]`|
+|                  |     |                     |replace |replace `[n0,v1,n_]`         |
+
+### Underflow
+
+|type              |index|                                       |                                               |
+|------------------|-----|---------------------------------------|-----------------------------------------------|
+|`[n0,v1,n2]`      |    0|`[[],v1,[v20]]`                        |underflow `[v1,v20]`                           |
+|                  |     |`[[],v1,[v20,v21]]`                    |replace `[[v1],v20,[v21]]`                     |
+|                  |     |`[[n_],v1,[n20,v21,n22]]`              |underflow `[n_,v1,n20,v21,n22]`                |
+|                  |     |`[[n_],v1,[n20,v21,n22,v23,n24]]`      |replace `[[n_,v1,n20],v21,[n22,v23,n24]]`      |
+|                  |    2|                                       |                                               |
+|`[n0,v1,n2,v3,n4]`|    0|`[[],v1,[v20],v3,n4]`                  |replace `[[v1,v20],v3,n4]`                     |
+|                  |     |`[[],v1,[v20,v21],v3,n4]`              |replace `[[v1],v20,[v21],v3,n4]`               |
+|                  |     |`[[n_],v1,[n20,v21,n22],v3,n4]`        |replace `[[n_,v1,n20,v21,n22],v3,n4]`          |
+|                  |     |`[[n_],v1,[n20,v21,n22,v23,n24],v3,n4]`|replace `[[n_,v1,n20],v21,[n22,v23,n24],v3,n4]`|
+|                  |    2|                                       |                                               |
+|                  |    4|                                       |                                               |
+
+## Concat (n0,n1)
+
+`concat` returns either `overflow 3` or `replace`:
+- `overflow 3`: `[n0,v1,n2]`
+- `replace`: `n`
+
+|`n0`                   |`n1`                   |                                                 |
+|-----------------------|-----------------------|-------------------------------------------------|
+|`[v00]`                |`[v10]`                |R `[v00,v10]`                                    |
+|                       |`[v10,v11]`            |O `[[v00],v10,[v11]]`                            |
+|`[v00,v01]`            |`n1`                   |O `[[v00],v01,n1]`                               |
+|`[n00,v01,n02]`        |`[n10,v11,n12]`        |`n00,v01,concat(n02,n10),v11,n12`                |
+|                       |`[n10,v11,n12,v13,n14]`|`n00,v01,concat(n02,n10),v11,n12,v13,n14`        |
+|`[n00,v01,n02,v03,n04]`|`[n10,v11,n12]`        |`n00,v01,n02,v03,concat(n04,n10),v11,n12`        |
+|                       |`[n10,v11,n12,v13,n14]`|`n00,v01,n02,v03,concat(n04,n10),v11,n12,v13,n14`|
+
+|source                                 |replace `cn`                        |overflow `[cn0,cv1,cn2]`                     |
+|---------------------------------------|------------------------------------|---------------------------------------------|
+|`n0,v1,concat(n2,n3),v4,n5`            |R `[n0,v1,cn,v2,n3]`                |O `[[n0,v1,cn0],cv1,[cn2,v4,n5]]`            |
+|`n0,v1,concat(n2,n3),v4,n5,v6,n7`      |O `[[n0,v1,cn],v4,[n5,v6,n7]]`      |O `[[n0,v1,cn0],cv1,[cn2,v4,n5,v6,n7]]`      |
+|`n0,v1,n2,v3,concat(n4,n5),v6,n7`      |O `[[n0,v1,n2],v3,[cn,v6,n7]]`      |O `[[n0,v1,n2,v3,cn0],cv1,[cn2,v6,n7]]`      |
+|`n0,v1,n2,v3,concat(n4,n5),v6,n7,v8,n9`|O `[[n0,v1,n2],v3,[cn,v6,n7,v8,n9]]`|O `[[n0,v1,n2,v3,cn0],cv1,[cn2,v6,n7,v8,n9]]`|

package/types/btree/index.js

@@ -138,7 +138,7 @@ const seq = require('../list')
 
 /**
  * @template T
- * @typedef { readonly [Node<T>, T, Node<T>, T, Node<T>, T, Node<T>] } Branch7
+ * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
 
 /** @type {<T>(n: Branch7<T>) => Branch3<T>} */
@@ -346,6 +346,91 @@ const values = node => () => {
     }
 }
 
+/**
+ * @template T
+ * @typedef {readonly[Node<T>]} Branch1
+ */
+
+/**
+ * @template T
+ * @typedef { Branch1<T> | Branch3<T> } ConcatResult
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[...Branch7<T>,T,Node<T>]} Branch9
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[...Branch9<T>,T,Node<T>]} Branch11
+ */
+
+/** @type {<T>(n: Branch5<T> | Branch7<T> | Branch9<T> | Branch11<T>) => Branch1<T> | Branch3<T>} */
+const up = n => {
+    switch (n.length) {
+        case 5: { return [n] }
+        case 7: {
+            const [n0, v1, n2, v3, n4, v5, n6] = n
+            return [[n0, v1, n2], v3, [n4, v5, n6]]
+        }
+        case 9: {
+            const [n0, v1, n2, v3, n4, v5, n6, v7, n8] = n
+            return [[n0, v1, n2], v3, [n4, v5, n6, v7, n8]]
+        }
+        case 11: {
+            const [n0, v1, n2, v3, n4, v5, n6, v7, n8, v9, n10] = n
+            return [[n0, v1, n2, v3, n4], v5, [n6, v7, n8, v9, n10]]
+        }
+    }
+}
+
+/**
+ * @template T
+ * @typedef {readonly[Node<T>,T]} Head2
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[...Head2<T>, ...Head2<T>]} Head4
+ */
+
+/** @type {<T>(n: Branch3<T> | Branch5<T>) => readonly[Head2<T>|Head4<T>, Node<T>]} */
+const bracnhSplit = n => {
+    if (n.length === 3) {
+        const [n0, v1, n2] = n
+        return [[n0, v1], n2]
+    } else {
+        const [n0, v1, n2, v3, n4] = n
+        return [[n0, v1, n2, v3], n4]
+    }
+}
+
+/** @type {<T>(a: Node<T>) => (b: Node<T>) => ConcatResult<T>} */
+const concat = a => b => {
+    /** @typedef {typeof a extends Node<infer T> ? T : never} T */
+    switch (a.length) {
+        case 1: {
+            switch (b.length) {
+                case 1: { return [[a[0], b[0]]] }
+                case 2: { return [a, b[0], [b[1]]] }
+                default: { throw 'invalid b node' }
+            }
+        }
+        case 2: { return [[a[0]], a[1], b] }
+        default: {
+            switch (b.length) {
+                case 3: case 5: {
+                    const [aHead, aLast] = bracnhSplit(a)
+                    const [bn0, ...b1] = b
+                    return up([...aHead, ...concat(aLast)(bn0), ...b1])
+                }
+                default: { throw 'invalid b node' }
+            }
+        }
+    }
+}
+
 module.exports = {
     /** @readonly */
     values,
@@ -363,5 +448,7 @@ module.exports = {
     /** @readonly */
     getOrInsertVisitor: visit(getOrInsertVisitor),
     /** @readonly */
-    replaceVisitor: visit(replaceVisitor)
+    replaceVisitor: visit(replaceVisitor),
+    /** @readonly */
+    concat,
 }

package/types/btree/test.js

@@ -1,5 +1,5 @@
 const btree = require('.')
-const { getVisitor, setVisitor, values } = btree
+const { getVisitor, setVisitor, values, concat } = btree
 const json = require('../../json')
 const { sort } = require('../object')
 const { stringCmp } = require('../function/compare')
@@ -56,6 +56,37 @@ const set = node => value => {
     if (result !== undefined) { throw result }
 }
 
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['1']
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString())
+    if (_map.length !== 3) { throw _map }
+    // console.log(_map)
+    let [a,,b] = _map
+    let _c = concat(a)(b)
+    // console.log(_c)
+    if (_c.length !== 3) { throw _c }
+    [a,,b] = _c
+    _c = concat(a)(b)
+    // console.log(_c)
+    if (_c.length !== 1) { throw _c }
+    let [_r] = _c
+    if (_r.length !== 5) { throw _r }
+    [a,,b] = _r
+    _c = concat(a)(b)
+    // console.log(_c)
+    if (_c.length !== 3) { throw _c }
+    [a,,b] = _c
+    _c = concat(a)(b)
+    // console.log(_c)
+    if (_c.length !== 3) { throw _c }
+    [a,,b] = _c
+    _c = concat(a)(b)
+    // console.log(_c)
+    if (_c.length !== 1) { throw _c }
+}
+
 const test = () => {
     /** @type {btree.Node<string>} */
     let _map = ['a']