functionalscript 0.0.281 → 0.0.285

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.281",
+  "version": "0.0.285",
   "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,83 @@ 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 ]]`|
+
+## 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,96 @@
+const _ = require('..')
+const { todo } = require('../../../dev')
+const list = require('../../list')
+const cmp = require('../../function/compare')
+
+/**
+ * @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<T>, 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 {(first: PathItem<T>) => Result<T>} */
+        const append = first => f({ first, tail })(child(first))
+        switch (node.length) {
+            case 1: { return [[i3(node[0]), node], tail] }
+            case 2: { return [[i5(node), node], tail] }
+            case 3: {
+                const i = i3(node[1])
+                switch (i) {
+                    case 0: case 2: { return append([i, node]) }
+                    case 1: { return [[i, node], tail] }
+                }
+            }
+            case 5: {
+                const i = i5([node[1], node[3]])
+                switch (i) {
+                    case 0: case 2: case 4: { return append([i, node]) }
+                    case 1: case 3: { return [[i, node], tail]}
+                }
+            }
+        }
+    }
+    return f(undefined)
+}
+
+module.exports = {
+    /** @readonly */
+    find,
+}

package/types/btree/find/test.js

@@ -0,0 +1,122 @@
+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 {(sequence: list.List<json.Unknown>) => string} */
+// const arrayStr = sequence => jsonStr(list.toArray(sequence))
+
+/** @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, path]) => jsonStr([r[0], list.toArray(list.map(x => x[0])(path))])
+
+/** @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

@@ -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,96 @@ 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
+ */
+
+/**
+ * @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]
+    } 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] = headLast(a)
+                    const [bFirst, ...bTail] = b
+                    return up([...aHead, ...concat(aLast)(bFirst), ...bTail])
+                }
+                default: { throw 'invalid b node' }
+            }
+        }
+    }
+}
+
 module.exports = {
     /** @readonly */
     values,
@@ -363,5 +453,7 @@ module.exports = {
     /** @readonly */
     getOrInsertVisitor: visit(getOrInsertVisitor),
     /** @readonly */
-    replaceVisitor: visit(replaceVisitor)
+    replaceVisitor: visit(replaceVisitor),
+    /** @readonly */
+    concat,
 }

package/types/btree/test.js

@@ -1,12 +1,16 @@
 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')
 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 => {
@@ -56,6 +60,48 @@ 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 }
+    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)
+    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)
+    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)
+    if (_c.length !== 3) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[["1"],"100",["25","49"]]') { throw _s }
+
+    [a,,b] = _c
+    _c = concat(a)(b)
+    if (_c.length !== 3) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[["1"],"25",["49"]]') { throw _s }
+
+    [a,,b] = _c
+    _c = concat(a)(b)
+    if (_c.length !== 1) { throw _c }
+    _s = jsonStr(_c);
+    if (_s !== '[["1","49"]]') { throw _s }
+}
+
 const test = () => {
     /** @type {btree.Node<string>} */
     let _map = ['a']

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()