functionalscript 0.3.4 → 0.3.5

package/types/bit_vec/test.f.ts

@@ -1,129 +0,0 @@
-import { empty, vec, length, concatLsb, uintLsb, uintMsb, removeLsb, concatMsb, removeMsb, uint, popUintLsb, popUintMsb } from './module.f.ts'
-
-export default {
-    examples: {
-        vec: () => {
-            const vec4 = vec(4n)
-            const v0 = vec4(5n)     // 0x15n
-            if (v0 !== 0x15n) { throw v0 }
-            const v1 = vec4(0x5FEn) // 0x1En
-            if (v1 !== 0x1En) { throw v1 }
-        },
-        uint: () => {
-            const vector = vec(8n)(0x5n) // 0x105n
-            if (vector !== 0x105n) { throw vector }
-            const result = uint(vector); // result is 0x5n
-            if (result !== 0x5n) { throw result }
-        },
-        uintLsb: () => {
-            const vector = vec(8n)(0xF5n) // 0x1F5n
-            if (vector !== 0x1F5n) { throw vector }
-            const result = uintLsb(4n)(vector); // result is 5n
-            if (result !== 5n) { throw result }
-            const result2 = uintLsb(16n)(vector); // result2 is 0xF5n
-            if (result2 !== 0xF5n) { throw result2 }
-        },
-        uintMsb: () => {
-            const vector = vec(8n)(0xF5n) // 0x1F5n
-            if (vector !== 0x1F5n) { throw vector }
-            const result = uintMsb(4n)(vector); // result is 0xFn
-            if (result !== 0xFn) { throw result }
-            const result2 = uintMsb(16n)(vector); // result2 is 0xF500n
-            if (result2 !== 0xF500n) { throw result2 }
-        },
-        popUintLsb: () => {
-            const vector = vec(8n)(0xF5n) // 0x1F5n
-            const [result, rest] = popUintLsb(4n)(vector); // result is 5n, rest is 0x1Fn
-            if (result !== 5n) { throw result }
-            if (rest !== 0x1Fn) { throw rest }
-            const [result2, rest2] = popUintLsb(16n)(vector); // result2 is 0xF5n, rest2 is 1n
-            if (result2 !== 0xF5n) { throw result2 }
-            if (rest2 !== 1n) { throw rest2 }
-        },
-        popUintMsb: () => {
-            const vector = vec(8n)(0xF5n) // 0x1F5n
-            const [result, rest] = popUintMsb(4n)(vector); // [0xFn, 0x15n]
-            if (result !== 0xFn) { throw result }
-            if (rest !== 0x15n) { throw rest }
-            const [result2, rest2] = popUintMsb(16n)(vector); // [0xF500n, 1n]
-            if (result2 !== 0xF500n) { throw result2 }
-            if (rest2 !== 1n) { throw rest2 }
-        },
-        concatLsb: () => {
-            const u8 = vec(8n)
-            const a = u8(0x45n) // 0x145n
-            if (a !== 0x145n) { throw a }
-            const b = u8(0x89n) // 0x189n
-            if (b !== 0x189n) { throw b }
-            const ab = concatLsb(a)(b) // 0x18945n
-            if (ab !== 0x18945n) { throw ab }
-        },
-        concatMsb: () => {
-            const u8 = vec(8n)
-            const a = u8(0x45n) // 0x145n
-            if (a !== 0x145n) { throw a }
-            const b = u8(0x89n) // 0x189n
-            if (b !== 0x189n) { throw b }
-            const ab = concatMsb(a)(b) // 0x14589n
-            if (ab !== 0x14589n) { throw ab }
-        },
-        removeLsb: () => {
-            const v = vec(16n)(0x3456n) // 0x13456n
-            if (v !== 0x13456n) { throw v }
-            const r = removeLsb(4n)(v) // 0x1345n
-            if (r !== 0x1345n) { throw r }
-            const r2 = removeLsb(24n)(v) // 0x1n
-            if (r2 !== 0x1n) { throw r2 }
-        },
-        removeMsb: () => {
-            const v = vec(16n)(0x3456n) // 0x13456n
-            if (v !== 0x13456n) { throw v }
-            const r = removeMsb(4n)(v) // 0x1456n
-            if (r !== 0x1456n) { throw r }
-            const r2 = removeMsb(24n)(v) // 0x1n
-            if (r2 !== 0x1n) { throw r2 }
-        }
-    },
-    uintLsb: () => {
-        const vector = 0b1110101n
-        const extract3Bits = uintLsb(3n)
-        const result = extract3Bits(vector) // result is 0b101n (5n)
-        if (result !== 0b101n) { throw result }
-    },
-    uintSmall: () => {
-        const vector = 0b11n
-        const extract3Bits = uintLsb(3n)(vector)
-        if (extract3Bits !== 0b1n) { throw extract3Bits }
-    },
-    vecExample: () => {
-        const createVector = vec(4n)
-        const vector = createVector(5n) // vector is 0b10101n
-        if (vector !== 0b10101n) { throw vector }
-    },
-    length: () => {
-        const i = length(empty)
-        if (i !== 0n) { throw i}
-    },
-    bitset: () => {
-        const v = vec(8n)(0x5FEn)
-        if (v !== 0x1FEn) { throw v }
-        if (length(v) !== 8n) { throw 'len' }
-        const u = uintLsb(8n)(v)
-        if (u !== 0xFEn) { throw v }
-    },
-    appendBack: () => {
-        const vec8 = vec(8n)
-        const a = vec8(0x345n)
-        const b = vec8(0x789n)
-        const ab = concatLsb(a)(b)
-        if (ab !== 0x18945n) { throw ab }
-        const s = length(ab)
-        if (s !== 16n) { throw `appendBack: ${s}` }
-    },
-    removeBack: () => {
-        const v = vec(17n)(0x12345n)
-        if (v !== 0x32345n) { throw v.toString(16) }
-        const r = removeLsb(9n)(v)
-        if (r !== 0x191n) { throw r.toString(16) }
-    }
-}

package/types/btree/README.md

@@ -1,160 +0,0 @@
-# B-tree
-
-https://en.wikipedia.org/wiki/B-tree
-
-## BTree 2-3 nodes
-
-`Node<T>`:
-
-- leaf1: `[T]`
-- leaf2: `[T,T]`
-- branch3: `[Node<T>, T, Node<T>]`
-- branch5: `[Node<T>, T, Node<T>, T, Node<T>]`
-
-## Result Types
-
-`Result<T>`:
-
-- { done: `true`, value: `T`,  } |
-  { done: `false` }
-- { replace: `Node<T>` }
-- { overflow: `Branch3<T>` }
-
-## Actions
-
-- found (6 functions)
-  - leaf1: `0`
-  - leaf2: `0 1`
-  - branch3: `1`
-  - branch5: `1 3`
-- notFound (5 functions)
-  - leaf1: `left right`
-  - leaf2: `left middle right`
-
-|type   |found|notFound           |
-|-------|-----|-------------------|
-|leaf1  |`0`  |`left right`       |
-|leaf2  |`0 1`|`left middle right`|
-|branch3|`1`  |_left right_       |
-|branch5|`1 3`|_left middle right_|
-
-Note: 5 transitional states:
-- branch3: _left right_
-- branch5: _left middle right_
-
-Posible actions:
-
-- found. It can return:
-  - get: { done: `true` ... }
-  - replace: { replace: ... }
-- notFound:
-  - none: { done: `false` }
-  - insert: { replace: ... } | { overflow: ... }
-
-|               |found.get  |found.replace  |
-|---------------|-----------|---------------|
-|notFound.none  |get        |replace        |
-|notFound.insert|getOrInsert|replaceOrInsert|
-
-## Branch3 Overflow
-
-- current `[n0 v1 n2]`
-- overflow `[L VM R]`
-
-|type  |index|{ replace: Branch5 }|
-|------|-----|--------------------|
-|left  |    0|`[(L VM R) v1 n2]`  |
-|right |    2|`[n0 v1 (L VM R)]`  |
-
-## Branch5 Overflow
-
-- current `[n0, v1, n2, v3, n4]`
-- overflow `[L, VM, R]`
-
-|type  |index|Operation           |Branch7                 |{ overflow: Branch3 }       |
-|------|-----|--------------------|------------------------|----------------------------|
-|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` 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
-
-`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`   |`[nR,v1,n2]`                            |
-|                  |    2|`[]`   |`[[v00, v1]]`                           |
-|                  |     |       |`[[v00],v01,[v1]]`                      |
-|                  |     |`[nR0]`|`[[n00, v01, n02, v1, nR0]]`            |
-|                  |     |       |`[[n00, v01, n02], v02, [n03, v1, nR0]]`|
-|                  |     |`nR`   |`[n0,v1,nR]`                            |
-|`[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/module.f.ts

@@ -1,92 +0,0 @@
-import * as _ from '../types/module.f.ts'
-import * as List from '../../list/module.f.ts'
-import * as cmp from '../../function/compare/module.f.ts'
-const { index3, index5 } = cmp
-import * as Array from '../../array/module.f.ts'
-
-type FirstLeaf1<T> = readonly[cmp.Index3, _.Leaf1<T>]
-
-type FirstBranch3<T> = readonly[1, _.Branch3<T>]
-
-type FirstLeaf2<T> = readonly[cmp.Index5, _.Leaf2<T>]
-
-type FirstBranch5<T> = readonly[1|3, _.Branch5<T>]
-
-type First<T> = FirstLeaf1<T> | FirstBranch3<T> | FirstLeaf2<T> | FirstBranch5<T>
-
-type PathItem3<T> = readonly[0|2, _.Branch3<T>]
-
-type PathItem5<T> = readonly[0|2|4, _.Branch5<T>]
-
-export type PathItem<T> = PathItem3<T> | PathItem5<T>
-
-const child
-= <T>(item: PathItem<T>): _.TNode<T> => (item[1][item[0]] as _.TNode<T>)
-
-export type Path<T> = List.List<PathItem<T>>
-
-export type Result<T> = {
-    readonly first: First<T>,
-    readonly tail: Path<T>
-}
-
-export const find
-= <T>(c: cmp.Compare<T>): (node: _.TNode<T>) => Result<T> => {
-    const i3 = index3(c)
-    const i5 = index5(c)
-    const f
-        = (tail: Path<T>) => (node: _.TNode<T>): Result<T> => {
-        const append
-            : (index: Array.KeyOf<typeof node>) => Result<T>
-            = index => {
-            const first = [index, node] as PathItem<T>
-            return f({ first, tail })(child(first))
-        }
-        const done
-            : (index: Array.KeyOf<typeof node>) => Result<T>
-            = index => ({ first: [index, node] as First<T>, tail })
-        switch (node.length) {
-            case 1: { return done(i3(node[0])) }
-            case 2: { return done(i5(node)) }
-            case 3: {
-                const i = i3(node[1])
-                switch (i) {
-                    case 0: case 2: { return append(i) }
-                    case 1: { return done(i) }
-                }
-            }
-            case 5: {
-                const i = i5([node[1], node[3]])
-                switch (i) {
-                    case 0: case 2: case 4: { return append(i) }
-                    case 1: case 3: { return done(i) }
-                }
-            }
-        }
-    }
-    return f(null)
-}
-
-export const isFound = <T>([i]: First<T>): boolean => {
-    switch (i) {
-        case 1: case 3: { return true }
-        default: { return false }
-    }
-}
-
-export const value = <T>([i, r]: First<T>): T | null => {
-    switch (i) {
-        case 1: {
-            switch (r.length) {
-                case 1: case 2: { return r[0] }
-                default: { return r[1] }
-            }
-        }
-        case 3: {
-            return r.length === 2 ? r[1] : r[3]
-        }
-        default: {
-            return null
-        }
-    }
-}

package/types/btree/find/test.f.ts

@@ -1,122 +0,0 @@
-import * as _ from './module.f.ts'
-import * as list from '../../list/module.f.ts'
-import * as json from '../../../json/module.f.ts'
-import * as o from '../../object/module.f.ts'
-const { sort } = o
-import * as btree from '../types/module.f.ts'
-import * as string from '../../string/module.f.ts'
-const { cmp } = string
-import * as s from '../set/module.f.ts'
-
-const jsonStr = json.stringify(sort)
-
-const set
-    : (node: btree.TNode<string>) => (value: string) => btree.TNode<string>
-    = node => value => s.set(cmp(value))(() => value)(node)
-
-const str
-    : (r: _.Result<json.Unknown>) => string
-    = r => jsonStr(list.toArray(list.map((x: any) => x[0])(r)))
-
-const find
-    : (i: string) => (m: btree.TNode<string>) => string
-    = i => m => str(_.find(cmp(i))(m))
-
-const test = () => {
-    let _map
-        : btree.TNode<string>
-        = ['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 }
-    }
-}
-
-export default test

package/types/btree/module.f.ts

@@ -1,35 +0,0 @@
-import * as list from '../list/module.f.ts'
-const { flat } = list
-import * as n from '../nullable/module.f.ts'
-const { map } = n
-import * as _ from './types/module.f.ts'
-
-const nodeValues
-    : <T>(node: _.TNode<T>) => list.Thunk<T>
-    = node => () => {
-    switch (node.length) {
-        case 1: case 2: { return node }
-        case 3: {
-            return flat([
-                nodeValues(node[0]),
-                [node[1]],
-                nodeValues(node[2])
-            ])
-        }
-        default: {
-            return flat([
-                nodeValues(node[0]),
-                [node[1]],
-                nodeValues(node[2]),
-                [node[3]],
-                nodeValues(node[4])
-            ])
-        }
-    }
-}
-
-export const empty = null
-
-export const values
-    : <T>(tree: _.Tree<T>) => list.List<T>
-    = map(nodeValues)

package/types/btree/remove/module.f.ts

@@ -1,151 +0,0 @@
-import * as _ from '../types/module.f.ts'
-import * as Cmp from '../../function/compare/module.f.ts'
-import * as find from '../find/module.f.ts'
-import * as list from '../../list/module.f.ts'
-const { fold, concat, next } = list
-import * as Array from '../../array/module.f.ts'
-import * as n from '../../nullable/module.f.ts'
-const { map } = n
-
-type Leaf01<T> = null | _.Leaf1<T>
-
-type RemovePath<T> = {
-   readonly first: Leaf01<T>,
-   readonly tail: find.Path<T>
-}
-
-const path
-    : <T>(tail: find.Path<T>) => (n: _.TNode<T>) => readonly[T, RemovePath<T>]
-    = tail => n => {
-    switch (n.length) {
-        case 1: { return [n[0], { first: null, 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]) }
-    }
-}
-
-type Branch<T> = _.Branch1<T> | _.Branch3<T> | _.Branch5<T>
-
-const reduceValue0
-    : <T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
-    = 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]
-    }
-}
-
-const reduceValue2
-    : <T>(a: Branch<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
-    = 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]
-    }
-}
-
-const initValue0
-    : <T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
-    = a => n => {
-    const [, v1, n2] = n
-    if (a === null) {
-        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]
-    }
-}
-
-const initValue1
-    : <T>(a: Leaf01<T>) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
-    = a => n => {
-    const [n0, v1] = n
-    if (a === null) {
-        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] }
-}
-
-type Merge<A, T> = (a: A) => (n: _.Branch3<T>) => _.Branch1<T> | _.Branch3<T>
-
-const reduceX
-    = <A, T>(ms: Array.Array2<Merge<A, T>>) => ([i, n]: find.PathItem<T>) => (a: A): Branch<T> => {
-    const [m0, m2] = ms
-    const f
-        : (m: Merge<A, T>) => Branch<T>
-        = m => {
-        const ra = m(a)
-        return n.length === 3 ? ra(n) : [...ra([n[0], n[1], n[2]]), n[3], n[4]]
-    }
-    switch (i) {
-        case 0: { return f(m0) }
-        case 2: { return f(m2) }
-        case 4: { return [n[0], n[1], ...m2(a)([n[2], n[3], n[4]])] }
-    }
-}
-
-const reduce = fold(reduceX([reduceValue0, reduceValue2]))
-
-const initReduce = reduceX([initValue0, initValue1])
-
-export const nodeRemove
-    = <T>(c: Cmp.Compare<T>) => (node: _.TNode<T>): _.Tree<T> => {
-    const f = (): null | RemovePath<T> => {
-        const { first, tail } = find.find(c)(node)
-        const branch
-            : (n: _.TNode<T>) => (f: (v: T) => find.PathItem<T>) => RemovePath<T>
-            = n => f => {
-            const [v, p] = path(null as find.Path<T>)(n)
-            return { first: p.first, tail: concat(p.tail)({ first: f(v), tail }) }
-        }
-        const [i, n] = first
-        switch (i) {
-            case 1: {
-                switch (n.length) {
-                    case 1: { return { first: null, 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: {
-                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 null }
-        }
-    }
-    const r = f()
-    if (r === null) { return node }
-    const { first, tail } = r
-    const tailR = next(tail)
-    if (tailR === null) { return first }
-    const { first: tf, tail: tt } = tailR
-    const result = reduce(initReduce(tf)(first))(tt)
-    return result.length === 1 ? result[0] : result
-}
-
-export const remove
-    : <T>(c: Cmp.Compare<T>) => (tree: _.Tree<T>) => _.Tree<T>
-    = c => map(nodeRemove(c))