functionalscript 0.0.279 → 0.0.283

package/package.json

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

package/test.js

@@ -9,6 +9,7 @@ require('./io/commonjs/test')
 require('./commonjs/package/dependencies/test')
 require('./commonjs/package/test')
 require('./commonjs/path/test')
+require('./types/function/compare/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

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/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,17 +1,105 @@
 const btree = require('.')
-const { setVisitor, values } = btree
-const { cmp } = require('../function/compare')
+const { getVisitor, setVisitor, values, concat } = btree
+const json = require('../../json')
+const { sort } = require('../object')
+const { stringCmp } = require('../function/compare')
 const list = require('../list')
 
+const jsonStr = json.stringify(sort)
+
+/** @type {(sequence: list.List<json.Unknown>) => string} */
+const stringify = sequence => jsonStr(list.toArray(sequence))
+
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
-    const result = setVisitor(cmp(value))(node)(() => value)
+    const result = setVisitor(stringCmp(value))(node)(() => value)
     switch (result[0]) {
         case 'replace': case 'overflow': { return result[1] }
         default: { return node }
     }
 }
 
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    _map = set(_map)('d')
+    _map = set(_map)('e')
+    _map = set(_map)('f')
+    let result = stringify(values(_map))
+    if (result !== '["a","b","c","d","e","f"]') { throw result }
+}
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['1']
+    for(let i = 2; i <= 10; i++)
+        _map = set(_map)((i*i).toString())
+    let result = stringify(values(_map))
+    if (result !== '["1","100","16","25","36","4","49","64","81","9"]') { throw result }
+}
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    const result = getVisitor(stringCmp('b'))(_map)
+    if (result === undefined) { throw result }
+}
+
+{
+    /** @type {btree.Node<string>} */
+    let _map = ['a']
+    _map = set(_map)('b')
+    _map = set(_map)('c')
+    const result = getVisitor(stringCmp('e'))(_map)
+    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/function/compare/index.js

@@ -3,7 +3,7 @@
 
 /**
  * @template T
- * @typedef {import('../../array').Array2<T>} Array2 
+ * @typedef {import('../../array').Array2<T>} Array2
  */
 
 /** @typedef {-1|0|1} Sign */
@@ -22,8 +22,14 @@ const index5 = cmp => ([v0, v1]) => {
     return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)
 }
 
+/** @type {<T>(a: T) => (b: T) => Sign} */
+const unsafeCmp = a => b => a < b ? -1 : a === b ? 0 : 1
+
 /** @type {(a: string) => (b: string) => Sign} */
-const cmp = a => b => a < b ? -1 : a === b ? 0 : 1
+const stringCmp = unsafeCmp
+
+/** @type {(a: number) => (b: number) => Sign} */
+const numberCmp = unsafeCmp
 
 module.exports = {
     /** @readonly */
@@ -31,5 +37,7 @@ module.exports = {
     /** @readonly */
     index5,
     /** @readonly */
-    cmp,
+    stringCmp,
+    /** @readonly */
+    numberCmp,
 }

package/types/function/compare/test.js

@@ -0,0 +1,13 @@
+const _ = require('.')
+
+{
+    const result = _.numberCmp(4)(5)
+    if (result !== -1) { throw result }
+}
+
+{
+    const result = _.stringCmp('3')('4')
+    if (result !== -1) { throw result }
+}
+
+module.exports = {}

package/types/map/index.js

@@ -2,7 +2,7 @@ const option = require("../option")
 const btree = require('../btree')
 const { getVisitor, setVisitor, values } = require("../btree")
 const compare = require("../function/compare")
-const { cmp } = require("../function/compare")
+const { stringCmp } = require("../function/compare")
 const list = require("../list")
 
 /** @typedef {compare.Sign} Sign */
@@ -33,7 +33,7 @@ const list = require("../list")
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
-const keyCmp = a => ([b]) => cmp(a)(b)
+const keyCmp = a => ([b]) => stringCmp(a)(b)
 
 /** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
 const at = name => map => {