functionalscript 0.0.278 → 0.0.282

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.278",
+  "version": "0.0.282",
   "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,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

@@ -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
@@ -122,19 +138,25 @@ 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>} */
 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 }
@@ -326,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,
@@ -334,14 +439,16 @@ 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),
     /** @readonly */
     getOrInsertVisitor: visit(getOrInsertVisitor),
     /** @readonly */
-    replaceVisitor: visit(replaceVisitor)
+    replaceVisitor: visit(replaceVisitor),
+    /** @readonly */
+    concat,
 }

package/types/btree/test.js

@@ -1,17 +1,92 @@
 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')
 
+/** @type {(sequence: list.List<json.Unknown>) => string} */
+const stringify = sequence => json.stringify(sort)(list.toArray(sequence))
+
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
-    const result = setVisitor(cmp(value))(() => value)(node)
+    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 }
+    // 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']

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 => {
@@ -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' }