functionalscript 0.0.291 → 0.0.295

package/README.md

@@ -203,17 +203,6 @@ x[0] = 3 // < invalid
 const f = () => x // < invalid
 ```
 
-
-
-This mutable object cannot be used in [closures](https://en.wikipedia.org/wiki/Closure_(computer_programming)) or nested functions.
-
-An example of incorrect code would look like this:
-
-```js
-let x = 5
-const f = () => x
-```
-
 ### 5.2 Return 
 
 [Return](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.0.291",
+  "version": "0.0.295",
   "description": "FunctionalScript is a functional subset of JavaScript",
   "main": "index.js",
   "scripts": {
@@ -28,7 +28,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^16.11.12",
-    "typescript": "^4.5.3"
+    "@types/node": "^16.11.19",
+    "typescript": "^4.5.4"
   }
 }

package/types/btree/README.md

@@ -79,14 +79,16 @@ Posible actions:
 
 ## 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|
+`concat` accepts `left` and `right` branches of the same level.
+
+|left         |right        |result                    |
+|-------------|-------------|--------------------------|
+|[an0]        |[bn0]        |[an0, value, r?]          |
+|[an0]        |[bn0,bv1,bn2]|[an0, value, r?, bv1, bn2]|
+|[an0,av1,an2]|[bn0]        |[an0, av1, an2, value, r?]|
+
+`popLeft` accepts `node` and returns
+`value` and `['leaf', [] | Leaf1]` | `['branch', Branch1 | Branch3 | Branch5]`
 
 ## Up
 

package/types/btree/find/index.js

@@ -98,7 +98,29 @@ const find = c => {
     return f(undefined)
 }
 
+/** @type {<T>(first: First<T>) => T | undefined} */
+const value = first => {
+    switch (first[0]) {
+        case 1: {
+            const x = first[1]
+            switch (x.length) {
+                case 1: case 2: { return x[0] }
+                default: { return x[1] }
+            }
+        }
+        case 3: {
+            const x = first[1]
+            return x.length === 2 ? x[1] : x[3]
+        }
+        default: {
+            return undefined
+        }
+    }
+}
+
 module.exports = {
     /** @readonly */
     find,
+    /** @readonly */
+    value,
 }

package/types/btree/find/test.js

@@ -4,17 +4,12 @@ const json = require('../../../json')
 const { sort } = require('../../object')
 const btree = require('..')
 const { stringCmp } = require('../../function/compare')
+const s = require('../set')
 
 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 }
-    }
-}
+const set = node => value => s.set(stringCmp(value))(value)(node)
 
 /** @type {(r: _.Result<json.Unknown>) => string} */
 const str = r => jsonStr(list.toArray(list.map(x => x[0])(r)))

package/types/btree/index.js

@@ -1,18 +1,5 @@
-const { todo } = require('../../dev')
-const cmp = require('../function/compare')
-const { index3, index5 } = cmp
 const seq = require('../list')
 
-/**
- * @template T
- * @typedef {() => T} Lazy
- */
-
-/**
- * @template T
- * @typedef {cmp.Compare<T>} Cmp
- */
-
 /**
  * @template T
  * @typedef {readonly[T]} Array1
@@ -61,268 +48,11 @@ const seq = require('../list')
  * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
-/** @typedef {readonly['done']} NotFoundDone */
-
-/**
- * @template T
- * @typedef {readonly['done', T]} FoundDone
- */
-
-/**
- * @template T
- * @typedef { NotFoundDone | FoundDone<T> } Done
- */
-
-/**
- * @template T
- * @typedef {readonly['replace', Node<T>]} Replace
- */
-
-/**
- * @template T
- * @typedef {readonly['overflow', Branch3<T>]} Overflow
- */
-
-/**
- * @template T
- * @typedef { Done<T> | Replace<T> | Overflow<T> } Result
- */
-
-/** @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 {{
- *  readonly leaf1: InLeaf1
- *  readonly leaf2_left: InLeaf2
- *  readonly leaf2_right: InLeaf2
- *  readonly branch3: InBranch3
- *  readonly branch5_left: InBranch5
- *  readonly branch5_right: InBranch5
- * }} Found
- */
-
-/**
- * @typedef {{
- *  readonly leaf1_left: InLeaf1
- *  readonly leaf1_right: InLeaf1
- *  readonly leaf2_left: InLeaf2
- *  readonly leaf2_middle: InLeaf2
- *  readonly leaf2_right: InLeaf2
- * }} 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
- *  readonly notFound: NotFound
- * }} Visitor
- */
-
 /**
  * @template T
  * @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: LazyResult<T>) =>
- *  LazyResult<T>}
- */
-const merge = extend => replace => lazyResult => init => {
-    const result = lazyResult(init)
-    switch (result[0]) {
-        case 'done': { return result }
-        case 'replace': { return ['replace', replace(result[1])] }
-        default: { return extend(result[1]) }
-    }
-}
-
-/** @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)
-    /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T */
-    /**
-     * @type {(extend: (o: Branch3<T>) => Branch5<T>) =>
-     *  (replace: (r: Node<T>) => Branch3<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: LazyResult<T>) =>
-     *  LazyResult<T>}
-     */
-    const merge3 = extend => merge(o => ['overflow', split(extend(o))])
-    /** @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(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(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(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
-}
-
-/** @type { <T>(_: T) => Done<T> } */
-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),
-}
-/** @type { () => () => NotFoundDone } */
-const notFound = () => () => ['done']
-
-/** @type {NotFound} */
-const notFoundGet = {
-    leaf1_left: notFound,
-    leaf1_right: notFound,
-    leaf2_left: notFound,
-    leaf2_middle: notFound,
-    leaf2_right: notFound,
-}
-
-/** @type { <T>(_: Node<T>) => Replace<T> } */
-const replace = node => ['replace', node]
-
-/** @type {Found} */
-const foundReplace = {
-    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>} */
-const overflow = ([v0, v1, v2]) => ['overflow', [[v0], v1, [v2]]]
-
-/** @type {NotFound} */
-const notFoundInsert = {
-    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} */
-const getVisitor = {
-    found: foundGet,
-    notFound: notFoundGet,
-}
-
-/** @type {Visitor} */
-const setVisitor = {
-    found: foundReplace,
-    notFound: notFoundInsert,
-}
-
-/** @type {Visitor} */
-const getOrInsertVisitor = {
-    found: foundGet,
-    notFound: notFoundInsert,
-}
-
-/** @type {Visitor} */
-const replaceVisitor = {
-    found: foundReplace,
-    notFound: notFoundGet,
-}
-
 /** @type {<T>(node: Node<T>) => seq.Thunk<T>} */
 const values = node => () => {
     switch (node.length) {
@@ -351,109 +81,7 @@ const values = node => () => {
  * @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,
-    /**
-     * @readonly
-     * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
-     */
-    getVisitor: cmp => node => {
-        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),
-    /** @readonly */
-    concat,
 }

package/types/btree/remove/index.js

@@ -0,0 +1,165 @@
+const _ = require('..')
+const { todo } = require('../../../dev')
+const cmp = require('../../function/compare')
+const find = require('../find')
+const list = require('../../list')
+const array = require('../../array')
+
+/**
+ * @template T
+ * @typedef {undefined | _.Leaf1<T>} Leaf01
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly first: Leaf01<T>,
+ *  readonly tail: find.Path<T>
+ * }} RemovePath
+ */
+
+/** @type {<T>(tail: find.Path<T>) => (n: _.Node<T>) => readonly[T, RemovePath<T>]} */
+const path = tail => n => {
+    switch (n.length) {
+        case 1: { return [n[0], { first: undefined, tail }] }
+        case 2: { return [n[0], { first: [n[1]], tail }] }
+        case 3: { return path({ first: [0, n], tail })(n[0]) }
+        case 5: { return path({ first: [0, n], tail })(n[0]) }
+    }
+}
+
+/**
+ * @template T
+ * @typedef {_.Branch1<T> | _.Branch3<T> | _.Branch5<T>} Branch
+ */
+
+/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const reduceValue0 = a => n => {
+    const [, v1, n2] = n
+    if (a.length === 1) {
+        switch (n2.length) {
+            case 3: { return [[a[0], v1, ...n2]] }
+            case 5: { return [[a[0], v1, n2[0]], n2[1], [n2[2], n2[3], n2[4]]] }
+            default: { throw 'invalid node' }
+        }
+    } else {
+        return [a, v1, n2]
+    }
+}
+
+/** @type {<T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const reduceValue2 = a => n => {
+    const [n0, v1, ] = n
+    if (a.length === 1) {
+        switch (n0.length) {
+            case 3: { return [[...n0, v1, a[0]]] }
+            case 5: { return [[n0[0], n0[1], n0[2]], n0[3], [n0[4], v1, a[0]]] }
+            default: { throw 'invalid node' }
+        }
+    } else {
+        return [n0, v1, a]
+    }
+}
+
+/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const initValue0 = a => n => {
+    const [, v1, n2] = n
+    if (a === undefined) {
+        switch (n2.length) {
+            case 1: { return [[v1, ...n2]] }
+            case 2: { return [[v1], n2[0], [n2[1]]] }
+            default: { throw 'invalid node' }
+        }
+    } else {
+        return [a, v1, n2]
+    }
+}
+
+/** @type {<T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} */
+const initValue1 = a => n => {
+    const [n0, v1] = n
+    if (a === undefined) {
+        switch (n0.length) {
+            case 1: { return [[...n0, v1]] }
+            case 2: { return [[n0[0]], n0[1], [v1]] }
+            default: { throw 'invalid node' }
+        }
+    } else { return [n0, v1, a] }
+}
+
+/**
+ * @template A,T
+ * @typedef {(a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>} Merge
+ */
+
+/** @type {<A, T>(ms: array.Array2<Merge<A, T>>) => (a: A) => (i: find.PathItem<T>) => Branch<T>} */
+const reduceX = ms => a => i => {
+    const [m0, m2] = ms
+    /** @typedef {typeof ms extends array.Array2<Merge<infer A, infer T>> ? [A,T] : never} AT */
+    /** @typedef {AT[0]} A */
+    /** @typedef {AT[1]} T */
+    /** @type {(m: Merge<A, T>) => Branch<T>} */
+    const f = m => {
+        const n = i[1]
+        const ra = m(a)
+        return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]]
+    }
+    switch (i[0]) {
+        case 0: { return f(m0) }
+        case 2: { return f(m2) }
+        case 4: {
+            const n = i[1]
+            return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])]
+        }
+    }
+}
+
+const reduce = list.reduce(reduceX([reduceValue0, reduceValue2]))
+
+const initReduce = reduceX([initValue0, initValue1])
+
+/** @type {<T>(c: cmp.Compare<T>) => (node: _.Node<T>) => undefined | _.Node<T>} */
+const remove = c => node => {
+    /** @typedef {typeof c extends cmp.Compare<infer T> ? T : never} T */
+    /** @type  {() => undefined | RemovePath<T>} */
+    const f = () => {
+        const { first, tail } = find.find(c)(node)
+        /** @type {(n: _.Node<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>} */
+        const branch = n => f => {
+            const [v, p] = path(/** @type {find.Path<T>} */(undefined))(n)
+            return { first: p.first, tail: list.concat(p.tail)({ first: f(v), tail }) }
+        }
+        switch (first[0]) {
+            case 1: {
+                const n = first[1]
+                switch (n.length) {
+                    case 1: { return { first: undefined, tail } }
+                    case 2: { return { first: [n[1]], tail } }
+                    case 3: { return branch(n[2])(v => [2, [n[0], v, n[2]]]) }
+                    case 5: { return branch(n[2])(v => [2, [n[0], v, n[2], n[3], n[4]]]) }
+                }
+            }
+            case 3: {
+                const n = first[1]
+                switch (n.length) {
+                    case 2: { return { first: [n[0]], tail } }
+                    case 5: { return branch(n[4])(v => [4, [n[0], n[1], n[2], v, n[4]]]) }
+                }
+            }
+            default: { return undefined }
+        }
+    }
+    const r = f()
+    if (r === undefined) { return node }
+    const { first, tail } = r
+    const tailR = list.next(tail)
+    if (tailR === undefined) { return first }
+    const { first: tf, tail: tt } = tailR
+    const result = reduce(initReduce(first)(tf))(tt)
+    return result.length === 1 ? result[0] : result
+}
+
+module.exports = {
+    /** @readonly */
+    remove,
+}

package/types/btree/remove/test.js

@@ -0,0 +1,487 @@
+const _ = require('.')
+const btree = require('..')
+const s = require('../set')
+const { stringCmp } = require('../../function/compare')
+const json = require('../../../json')
+const { sort } = require('../../object')
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => s.set(stringCmp(value))(value)(node)
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string> | undefined} */
+const remove = node => value => _.remove(stringCmp(value))(node)
+
+const jsonStr = json.stringify(sort)
+
+{
+    /** @type {btree.Node<string> | undefined} */
+    let _map = ['1']
+    for (let i = 2; i <= 38; i++)
+        _map = set(_map)((i * i).toString())
+    {
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225"]]],' +
+            '"1296",' +
+            '[[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]]],' +
+            '"25",' +
+            '[[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("0")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[[["1"],"100",["1024"]],"1089",[["1156"],"121",["1225"]]],' +
+            '"1296",' +
+            '[[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]]],' +
+            '"25",' +
+            '[[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]],' +
+            '"25",' +
+            '[[["256"],"289",["324"],"36",["361"]],"4",[["400"],"441",["484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("4")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]],' +
+            '"25",' +
+            '[[["256"],"289",["324"]],"36",[["361"],"400",["441","484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"9",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("9")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"]],"16",[["169"],"196",["225"]]],' +
+            '"25",' +
+            '[[["256"],"289",["324"]],"36",[["361"],"400",["441","484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("16")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]]],' +
+            '"25",' +
+            '[[["256"],"289",["324"]],"36",[["361"],"400",["441","484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("25")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289","324"],"36",["361"],"400",["441","484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("36")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"49",' +
+            '[[["529"],"576",["625"]],"64",[["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("49")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576","625"],"64",["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("64")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"],"729",["784"]],"81",[["841"],"900",["961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("81")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["100","1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("100")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156"],"121",["1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("121")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369"],"144",["1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("144")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"169",["196","225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("169")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"196",["225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("196")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369"],"1444",["225"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("225")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],"256",[["289"],"324",["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("256")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],"289",[["324","361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("289")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],"324",[["361"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("324")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],"361",[["400"],"441",["484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("361")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"400",["441","484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("400")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"441",["484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("441")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[[["1024"],"1089",["1156","1225"]],"1296",[["1369"],"1444",["484"]]],' +
+            '"529",' +
+            '[[["576"],"625",["676"]],"729",[["784"],"841",["900","961"]]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("484")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],' +
+            '"529",' +
+            '[["576"],"625",["676"]],' +
+            '"729",' +
+            '[["784"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("529")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"576",["625","676"]],' +
+            '"729",' +
+            '[["784"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("576")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"625",["676"]],' +
+            '"729",' +
+            '[["784"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("625")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369"],"1444",["676"]],' +
+            '"729",' +
+            '[["784"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("676")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],' +
+            '"729",' +
+            '[["784"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("729")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]],' +
+            '"784",' +
+            '[["841"],"900",["961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("784")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"841",["900","961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("841")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369","1444"],"900",["961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("900")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[[["1024"],"1089",["1156","1225"]],"1296",[["1369"],"1444",["961"]]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("961")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[["1024"],"1089",["1156","1225"],"1296",["1369","1444"]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1024")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[["1089"],"1156",["1225"],"1296",["1369","1444"]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1089")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[["1156","1225"],"1296",["1369","1444"]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1156")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[["1225"],"1296",["1369","1444"]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1225")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '[["1296"],"1369",["1444"]]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1296")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !==
+            '["1369","1444"]'
+        ) { throw r }
+    }
+    {
+        _map = remove(_map)("1369")
+        if (_map === undefined) { throw 'undefined' }
+        const r = jsonStr(_map)
+        if (r !== '["1444"]') { throw r }
+    }
+    {
+        _map = remove(_map)("1444")
+        if (_map !== undefined) { throw _map }
+    }
+}
+
+{
+    /** @type {btree.Node<string>|undefined} */
+    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 }
+
+    {
+        _map = remove(_map)("4")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[[["1","100"],"16",["25","36"]],"49",[["64"],"81",["9"]]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("49")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","36"],"64",["81","9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("64")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","36"],"81",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("81")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25"],"36",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("36")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"16",["25","9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("16")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1","100"],"25",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("25")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '[["1"],"100",["9"]]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("100")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '["1","9"]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("9")
+        if (_map === undefined) { throw _map }
+        _s = jsonStr(_map);
+        if (_s !== '["1"]') { throw _s }
+    }
+
+    {
+        _map = remove(_map)("1")
+        if (_map !== undefined) { throw _map }
+    }
+}

package/types/btree/set/index.js

@@ -5,13 +5,13 @@ const list = require('../../list')
 
 /**
  * @template T
- * @typedef {_.Branch1<T> | _.Branch3<T>} Result
+ * @typedef {_.Branch1<T> | _.Branch3<T>} Bracnh1To3
  */
 
-/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Result<T>} */
+/** @type {<T>(b: _.Branch5<T> | _.Branch7<T>) => Bracnh1To3<T>} */
 const b57 = b => b.length === 5 ? [b] : [[b[0], b[1], b[2]], b[3], [b[4], b[5], b[6]]]
 
-/** @type {<T>(a: Result<T>) => (i: find.PathItem<T>) => Result<T>} */
+/** @type {<T>(a: Bracnh1To3<T>) => (i: find.PathItem<T>) => Bracnh1To3<T>} */
 const reduce = a => i => {
     switch (i[0]) {
         case 0: {
@@ -39,7 +39,7 @@ const reduce = a => i => {
 const set = c => value => node => {
     const { first, tail } = find.find(c)(node)
     /** @typedef {typeof value} T */
-    /** @type {() => Result<T>} */
+    /** @type {() => Bracnh1To3<T>} */
     const f = () => {
         switch (first[0]) {
             case 0: {

package/types/btree/test.js

@@ -1,12 +1,15 @@
 const btree = require('.')
-const { getVisitor, setVisitor, values, concat } = btree
+const { values } = btree
 const json = require('../../json')
 const { sort } = require('../object')
 const { stringCmp } = require('../function/compare')
 const list = require('../list')
+const s = require('./set')
+const f = require('./find')
 
 require('./find/test')
 require('./set/test')
+require('./remove/test')
 
 const jsonStr = json.stringify(sort)
 
@@ -14,13 +17,7 @@ const jsonStr = json.stringify(sort)
 const stringify = sequence => jsonStr(list.toArray(sequence))
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
-const set = node => value => {
-    const result = setVisitor(stringCmp(value))(node)(() => value)
-    switch (result[0]) {
-        case 'replace': case 'overflow': { return result[1] }
-        default: { return node }
-    }
-}
+const set = node => value => s.set(stringCmp(value))(value)(node)
 
 {
     /** @type {btree.Node<string>} */
@@ -48,8 +45,8 @@ const set = node => value => {
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
-    const result = getVisitor(stringCmp('b'))(_map)
-    if (result === undefined) { throw result }
+    const result = f.value(f.find(stringCmp('b'))(_map).first)
+    if (result !== 'b') { throw result }
 }
 
 {
@@ -57,52 +54,10 @@ const set = node => value => {
     let _map = ['a']
     _map = set(_map)('b')
     _map = set(_map)('c')
-    const result = getVisitor(stringCmp('e'))(_map)
+    const result = f.value(f.find(stringCmp('e'))(_map).first)
     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/map/index.js

@@ -1,6 +1,8 @@
 const option = require("../option")
 const btree = require('../btree')
-const { getVisitor, setVisitor, values } = require("../btree")
+const { values } = require("../btree")
+const find = require('../btree/find')
+const s = require('../btree/set')
 const compare = require("../function/compare")
 const { stringCmp } = require("../function/compare")
 const list = require("../list")
@@ -38,7 +40,7 @@ const keyCmp = a => ([b]) => stringCmp(a)(b)
 /** @type {(name: string) => <T>(map: Map<T>) => T|undefined} */
 const at = name => map => {
     if (map === undefined) { return undefined }
-    const result = getVisitor(keyCmp(name))(map)
+    const result = find.value(find.find(keyCmp(name))(map).first)
     return result === undefined ? undefined : result[1]
 }
 
@@ -47,11 +49,7 @@ const set = name => value => map =>  {
     /** @type {Entry<typeof value>} */
     const entry = [name, value]
     if (map === undefined) { return [entry] }
-    const result = setVisitor(keyCmp(name))(map)(() => entry)
-    switch (result[0]) {
-        case 'replace': case 'overflow': { return result[1] }
-        default: { throw 'invalid BTree operation' }
-    }
+    return s.set(keyCmp(name))(entry)(map)
 }
 
 /** @type {<T>(map: Map<T>) => list.List<Entry<T>>} */