functionalscript 0.0.282 → 0.0.286

package/package.json

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

package/types/array/index.js

@@ -54,6 +54,18 @@ const seq = require('../list')
 
 /** @typedef {0|1|2|3|4} Index5 */
 
+/**
+ * @template T
+ * @typedef {T extends Array1<infer _> ? Index1 :
+ *  T extends Array2<infer _> ? Index2 :
+ *  T extends Array3<infer _> ? Index3 :
+ *  T extends Array4<infer _> ? Index4 :
+ *  T extends Array5<infer _> ? Index5 :
+ *  T extends readonly (infer _)[] ? number :
+ *  never
+ * } KeyOf
+ */
+
 /** @type {<T>(_: readonly T[]) => readonly T[]} */
 const uncheckTail = a => a.slice(1)
 

package/types/btree/README.md

@@ -77,55 +77,82 @@ Posible actions:
 |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]]`|
+## Concat
+
+`concat` returns either `Branch1` or `Branch3`
+
+|`a`               |`b`                |                                                 |size |
+|------------------|-------------------|-------------------------------------------------|-----|
+|`[av]`            |`[bv]`             |`[[av,bv]]`                                      |     |
+|                  |`[bv0,bv1]`        |`[a,bv0,[bv1]]`                                  |     |
+|`[av0,av1]`       |                   |`[[av0],av1,b]`                                  |     |
+|`[...aHead,aLast]`|`[bFirst,...bLast]`|`up([...aHead,...concat(aLast,bFirst),...bTail])`|5..11|
+
+## Up
+
+`up` returns `Branch1` or `Branch3`
+
+|`n.lenght`|                          |
+|----------|--------------------------|
+|5         |`[n]`                     |
+|7         |`[n[0...2],n[3],n[4...6]]`|
+|9         |`[n[0...2],n[3],n[4...8]]`|
+|11        |`[n[0...4],n[5],n[6...A]]`|
+
+## Delete
+
+`delete` returns `['leaf', [] | Leaf1]` | `['branch', Branch1 | Branch3 | Branch5]`
+
+|type              |index|r                                |
+|------------------|-----|---------------------------------|
+|`[v]`             |    0|leaf `[]`                        |
+|`[v0,v1]`         |    0|leaf `[v1]`                      |
+|                  |    1|leaf `[v2]`                      |
+|`[n0,v1,n2]`      |    1|branch `concat(n0,n2)`           |
+|`[n0,v1,n2,v3,n4]`|    1|branch `[...concat(n0,n2),v3,n4]`|
+|                  |    3|branch `[n0,v1,...concat(n2,n4)]`|
+
+|type              |index|nR     |                                        |
+|------------------|-----|-------|----------------------------------------|
+|`[n0,v1,n2]`      |    0|`[]`   |`[[v1, v20]]`                           |
+|                  |     |       |`[[v1],v20,[v21]]`                      |
+|                  |     |`[nR0]`|`[[nR0, v1, n20, v21, n22]]`            |
+|                  |     |       |`[[nR0, v1, n20], v21, [n22, v23, n23]]`|
+|                  |     |`nR`   |`[r,v1,n2]`                             |
+|                  |    2|`[]`   |`[[v00, v1]]`                           |
+|                  |     |       |`[[v00],v01,[v1]]`                      |
+|                  |     |`[nR0]`|`[[n00, v01, n02, v1, nR0]]`            |
+|                  |     |       |`[[n00, v01, n02], v02, [n03, v1, nR0]]`|
+|                  |     |`nR`   |`[n0,v1,r]`                             |
+|`[n0,v1,n2,v3,n4]`|    0|`[]`   |`[[v1,v20],v3,n4]`                      |
+|                  |     |       |`[[v1],v20,[v21],v3,n4]`                |
+|                  |     |`[nR0]`|`[[nR0,v1,n20,v21,n22],v3,n4]`          |
+|                  |     |       |`[[nR0,v1,n20],v21,[n22,v23,n24],v3,n4]`|
+|                  |     |`nR`   |`[nR,v1,n2,v3,n4]`                      |
+|                  |    2|`[]`   |`[[v00,v1],v3,n4]`                      |
+|                  |     |       |`[[v00],v01,[v1],v3,n4]`                |
+|                  |     |`[nR0]`|`[[n00,v01,n02,v1,nR0],v3,n4]`          |
+|                  |     |       |`[[n00,v01,n02],v03,[n04,v1,nR0],v3,n4]`|
+|                  |     |`nR`   |`[n0,v1,nR,v2,n4]`                      |
+|                  |    4|`[]`   |`[n0,v1,[v20,v3]]`                      |
+|                  |     |       |`[n0,v1,[v20],v21,[v3]]`                |
+|                  |     |`[nR0]`|`[n0,v1,[n20,v21,n22,v3,nR0]]`          |
+|                  |     |       |`[n0,v1,[n20,v21,n22],v23,[n24,v3,nR0]]`|
+|                  |     |`nR`   |`[n0,v1,n2,v3,nR]`                      |
+
+## Insert
+
+`insert` returns `Branch1` or `Branch3`
+
+|type              |                                 |size|
+|------------------|---------------------------------|----|
+|`[v]`             |`[[vI,v]]`                       |    |
+|                  |`[[v,vI]]`                       |    |
+|`[v0,v1]`         |`[[vI],v0,[v1]]`                 |    |
+|                  |`[[v0],vI,[v1]]`                 |    |
+|                  |`[[v0],v1,[vI]]`                 |    |
+|`[n0,v1,n2]`      |`up([...insert(n0),v1,n2])`      |3..5|
+|                  |`up([n0,v1,...insert(n2)])`      |3..5|
+|`[n0,v1,n2,v3,n4]`|`up([...insert(n0),v1,n2,v3,n4])`|5..7|
+|                  |`up([n0,v1,...insert(n2),v3,n4])`|5..7|
+|                  |`up([n0,v1,n2,v3,...insert(n4)])`|5..7|

package/types/btree/find/index.js

@@ -0,0 +1,104 @@
+const _ = require('..')
+const list = require('../../list')
+const cmp = require('../../function/compare')
+const array = require('../../array')
+
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index3, _.Leaf1<T>|_.Branch3<T>]} FirstLeaf1
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[1, _.Branch3<T>]} FirstBranch3
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[cmp.Index5, _.Leaf2<T>]} FirstLeaf2
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[1|3, _.Branch5<T>]} FirstBranch5
+ */
+
+/**
+ * @template T
+ * @typedef {FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>} First
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[0|2, _.Branch3<T>]} PathItem3
+ */
+
+/**
+ * @template T
+ * @typedef {readonly[0|2|4, _.Branch5<T>]} PathItem5
+ */
+
+/**
+ * @template T
+ * @typedef {PathItem3<T> | PathItem5<T>} PathItem
+ */
+
+/** @type {<T>(item: PathItem<T>) => _.Node<T>} */
+const child = item => {
+    /** @typedef {typeof item extends PathItem<infer T> ? T : never} T */
+    return /** @type {_.Node<T>} */(item[1][item[0]])
+}
+
+/**
+ * @template T
+ * @typedef {list.List<PathItem<T>>} Path
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: First<T>,
+ *  readonly tail: Path<T>
+ * }} Result<T>
+ */
+
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => Result<T>} */
+const find = c => {
+    const i3 = cmp.index3(c)
+    const i5 = cmp.index5(c)
+    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @type {(prior: Path<T>) => (node: _.Node<T>) => Result<T>} */
+    const f = tail => node => {
+        /** @type {(index: array.KeyOf<typeof node>) => Result<T>} */
+        const append = index => {
+            const first = /** @type {PathItem<T>} */([index, node])
+            return f({ first, tail })(child(first))
+        }
+        /** @type {(index: array.KeyOf<typeof node>) => Result<T>} */
+        const done = index => ({ first: /** @type {First<T>} */([index, node]), tail })
+        switch (node.length) {
+            case 1: { return done(i3(node[0])) }
+            case 2: { return done(i5(node)) }
+            case 3: {
+                const i = i3(node[1])
+                switch (i) {
+                    case 0: case 2: { return append(i) }
+                    case 1: { return done(i) }
+                }
+            }
+            case 5: {
+                const i = i5([node[1], node[3]])
+                switch (i) {
+                    case 0: case 2: case 4: { return append(i) }
+                    case 1: case 3: { return done(i) }
+                }
+            }
+        }
+    }
+    return f(undefined)
+}
+
+module.exports = {
+    /** @readonly */
+    find,
+}

package/types/btree/find/test.js

@@ -0,0 +1,119 @@
+const _ = require('.')
+const list = require('../../list')
+const json = require('../../../json')
+const { sort } = require('../../object')
+const btree = require('..')
+const { stringCmp } = require('../../function/compare')
+
+const jsonStr = json.stringify(sort)
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => {
+    const result = btree.setVisitor(stringCmp(value))(node)(() => value)
+    switch (result[0]) {
+        case 'replace': case 'overflow': { return result[1] }
+        default: { return node }
+    }
+}
+
+/** @type {(r: _.Result<json.Unknown>) => string} */
+const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))
+
+/** @type {(i: string) => (m: btree.Node<string>) => string} */
+const find = i => m => str(_.find(stringCmp(i))(m))
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['1']
+    for (let i = 2; i <= 10; i++)
+        _map = set(_map)((i * i).toString())
+    {
+        const s = jsonStr(_map)
+        if (s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw s }
+    }
+    //
+    {
+        const r = find("0")(_map)
+        if (r !== '[0,0,0]') { throw r }
+    }
+    {
+        const r = find("1")(_map)
+        if (r !== '[1,0,0]') { throw r }
+    }
+    {
+        const r = find("10")(_map)
+        if (r !== '[2,0,0]') { throw r }
+    }
+    {
+        const r = find("100")(_map)
+        if (r !== '[3,0,0]') { throw r }
+    }
+    {
+        const r = find("12")(_map)
+        if (r !== '[4,0,0]') { throw r }
+    }
+    {
+        const r = find("16")(_map)
+        if (r !== '[1,0]') { throw r }
+    }
+    {
+        const r = find("17")(_map)
+        if (r !== '[0,2,0]') { throw r }
+    }
+    {
+        const r = find("25")(_map)
+        if (r !== '[1,2,0]') { throw r }
+    }
+    {
+        const r = find("26")(_map)
+        if (r !== '[2,2,0]') { throw r }
+    }
+    {
+        const r = find("36")(_map)
+        if (r !== '[3,2,0]') { throw r }
+    }
+    {
+        const r = find("37")(_map)
+        if (r !== '[4,2,0]') { throw r }
+    }
+    {
+        const r = find("4")(_map)
+        if (r !== '[1]') { throw r }
+    }
+    {
+        const r = find("41")(_map)
+        if (r !== '[0,0,2]') { throw r }
+    }
+    {
+        const r = find("49")(_map)
+        if (r !== '[1,0,2]') { throw r }
+    }
+    {
+        const r = find("5")(_map)
+        if (r !== '[2,0,2]') { throw r }
+    }
+    {
+        const r = find("64")(_map)
+        if (r !== '[1,2]') { throw r }
+    }
+    {
+        const r = find("65")(_map)
+        if (r !== '[0,2,2]') { throw r }
+    }
+    {
+        const r = find("81")(_map)
+        if (r !== '[1,2,2]') { throw r }
+    }
+    {
+        const r = find("85")(_map)
+        if (r !== '[2,2,2]') { throw r }
+    }
+    {
+        const r = find("9")(_map)
+        if (r !== '[3,2,2]') { throw r }
+    }
+    {
+        const r = find("91")(_map)
+        if (r !== '[4,2,2]') { throw r }
+    }
+}

package/types/btree/index.js

@@ -395,8 +395,13 @@ const up = n => {
  * @typedef {readonly[...Head2<T>, ...Head2<T>]} Head4
  */
 
-/** @type {<T>(n: Branch3<T> | Branch5<T>) => readonly[Head2<T>|Head4<T>, Node<T>]} */
-const bracnhSplit = n => {
+/**
+ * @template T
+ * @typedef {Head2<T>|Head4<T>} Head
+ */
+
+/** @type {<T>(n: Branch3<T> | Branch5<T>) => readonly[Head<T>, Node<T>]} */
+const headLast = n => {
     if (n.length === 3) {
         const [n0, v1, n2] = n
         return [[n0, v1], n2]
@@ -421,9 +426,9 @@ const concat = a => 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])
+                    const [aHead, aLast] = headLast(a)
+                    const [bFirst, ...bTail] = b
+                    return up([...aHead, ...concat(aLast)(bFirst), ...bTail])
                 }
                 default: { throw 'invalid b node' }
             }

package/types/btree/test.js

@@ -5,8 +5,12 @@ const { sort } = require('../object')
 const { stringCmp } = require('../function/compare')
 const list = require('../list')
 
+require('./find/test')
+
+const jsonStr = json.stringify(sort)
+
 /** @type {(sequence: list.List<json.Unknown>) => string} */
-const stringify = sequence => json.stringify(sort)(list.toArray(sequence))
+const stringify = sequence => jsonStr(list.toArray(sequence))
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
@@ -62,29 +66,40 @@ const set = node => value => {
     for (let i = 2; i <= 10; i++)
         _map = set(_map)((i * i).toString())
     if (_map.length !== 3) { throw _map }
-    // console.log(_map)
+    let _s = jsonStr(_map)
+    if (_s !== '[[["1","100"],"16",["25","36"]],"4",[["49"],"64",["81","9"]]]') { throw _s }
+
     let [a,,b] = _map
     let _c = concat(a)(b)
-    // console.log(_c)
     if (_c.length !== 3) { throw _c }
+    _s =jsonStr(_c);
+    if (_s !== '[[["1","100"],"16",["25"]],"36",[["49"],"64",["81","9"]]]') { throw _s }
+
     [a,,b] = _c
     _c = concat(a)(b)
-    // console.log(_c)
     if (_c.length !== 1) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[[["1","100"],"16",["25","49"],"64",["81","9"]]]') { throw _s }
+
     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 }
+    _s = jsonStr(_c);
+    if (_s !== '[["1"],"100",["25","49"]]') { throw _s }
+
     [a,,b] = _c
     _c = concat(a)(b)
-    // console.log(_c)
     if (_c.length !== 3) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[["1"],"25",["49"]]') { throw _s }
+
     [a,,b] = _c
     _c = concat(a)(b)
-    // console.log(_c)
     if (_c.length !== 1) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[["1","49"]]') { throw _s }
 }
 
 const test = () => {

package/types/list/test.js

@@ -337,6 +337,15 @@ const stress = () => {
         const len = _.length(_.dropWhile(() => true)(result))
         if (len !== 0) { throw len }
     }
+
+    console.log('reverse')
+
+    {
+        // 10_000_000 is too much
+        const n = 5_000_000
+        const result = _.toArray(_.reverse(_.countdown(n)))
+        if (result.length !== n) { throw result.length }
+    }
 }
 
 // stress()