functionalscript 0.0.293 → 0.0.297

package/LANGUAGE.md

@@ -0,0 +1,208 @@
+# FunctionaScript Programming Language
+
+## 1. Module Ecosystem
+
+FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,
+
+```js
+const thirdPartyModule = require('third-party-package/module')
+
+const result = thirdPartyModule.someFunction('hello')
+```
+
+## 2. Packages
+
+FunctionalScript uses a `package.json` file to define a package. This file is compatible with [Node.js `package.json`](https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/).
+The prefered way to refence dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
+
+```json
+{
+   // ...
+   "dependencies": {
+      "third-party-package": "github:exampleorg/thirdpartypackage"
+   }
+   // ...
+}
+```
+
+**Note:** this repository is also a FunctionalScript package, and it can be used as a library. To install this package, use
+
+```
+npm install -S github:functionalscript/functionalscript
+```
+
+## 3. Module Structure
+
+A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
+
+`./first.js`
+```js
+// 1. references
+const math = require('math')
+
+// 2. definitions
+const myConst = 42
+// addition(a)(b) = a + b
+const addition = a => b => a + b
+const add42 = addition(42)
+const _10digitsOfPi = math.calculatePi(10)
+
+// 3. exports
+module.exports = {
+   addition,
+   add42,
+   _10digitsOfPi,
+}
+```
+
+`./second.js`
+```js
+// 1. references
+const first = require('./first.js')
+
+// 2. definitions
+const _42plus7 = first.add42(7)
+
+// 3. exports
+module.exports = {
+   _42plus7,
+}
+```
+
+## 4. References To Other Modules
+
+The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example,
+
+```js
+const math = require('math')
+const algebra = require('math/algebra')
+const localFile = require('../some-directory/some-file.js')
+```
+
+## 5. Definitions
+
+The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
+
+```js
+const myConst = 42
+const functionDouble = a => a * 2
+const structure = { name: "John", surname: "Smith" }
+const array = [1, 2, 3]
+const nestedStructure = {
+   address: undefined,
+   serialNumber: "123-45-78",
+   sum: 14 + myConst + functionDouble(4),
+   moreInfo: {
+      name: "Ivan",
+      surname: "Terrible",
+   }
+}
+```
+
+See [Expressions](#7-Expressions).
+
+### 6. Exports
+
+The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
+the end of a FunctionalScript file. For example,
+
+```js
+module.exports = {
+   nestedStructure,
+   array,
+   structure,
+}
+```
+
+## 7. Expressions
+
+Expressions could fall under these categories:
+
+- Literals:
+  - Number Literals, e.g. `0`, `3.14`, `4e8`
+  - Boolean Literals: `true` or `false`
+  - A `null` Literal
+  - An `undefined` Literal
+  - String Literals, e.g. `"Hello world!"`
+- Complex Structures
+  - Arrays, e.g. `[2, 5]`
+  - Objects, e.g. `{ a: "Hello", b: "world!" }`
+  - Arrow functions, e.g. `x => x * 2`
+- Operators
+  - Comparison Operators: `===`, `!==`, `>`, `>=`, `<`, `<=`
+  - Arithmetic Operators: `+`, `-`, `*`, `/`, `%`, `**`
+  - Bitwise Operators: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
+  - Logical Operators: `&&`, `||`, `!`, `??`
+  - Conditional Operator, e.g. `condition ? val1 : val2`
+  - Template Literals, e.g. `string ${expression}`
+  - `typeof`
+  - Relations Operators: `in`, `instanceof`.
+  - Member Operators: `.`, `[]`.
+
+Note: the `.` member operator has prohibitted property names, such as `constructor` and `push`. To access such properties, it's recommeded to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
+
+## 8. Arrow Functions
+
+An arrow function is also known as [a lambda function](https://en.wikipedia.org/wiki/Anonymous_function).
+The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow function must have either a single argument or no arguments at all. For example
+
+```js
+x => x * 2
+a => a + 4
+s => `template literal ${s}`
+a => b => a + b // an arrow functions that returns another arrow functions.
+() => 'hello' // an arrow function with no arguments
+```
+
+A function body is either an expression or a block statement. A block statement format is `{ A_LIST_OF_STATEMENTS }`. For example
+
+```js
+// a function with one argument and a block statement
+const f = x => {
+   const a = 2 + x
+   const r = a + 4
+   return r
+}
+```
+
+## 9. Statements
+
+`{ A_LIST_OF_STATEMENTS }` is one or many statements seperated by the newline control character. One of these statements mentioned earlier was [definition](#5-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
+
+### 9.1. Let
+
+[Let](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) declares a local mutable alias for immutable objects. For example
+
+```js
+let x = [5]
+// you can assign another immutable object to the alias at any time.
+x = [3, 4]
+//but you can't change the properties of the immutable object.
+x[0] = 3 // < invalid
+//let aliases can not be referenced from another arrow function.
+const f = () => x // < invalid
+```
+
+### 9.2. Return
+
+[Return](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/return)
+
+### 9.3. If...Else
+
+[If...Else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
+
+### 9.4. Switch
+
+[Switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
+
+### 9.5. Throw
+
+[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions but it doesn't catch them. You should only be using Statement throw in non-recoverable situations. It could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
+
+### 9.6. While
+
+[While](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while)
+
+### 9.7. Block
+
+[Block](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)

package/README.md

@@ -1,239 +1,21 @@
 # FunctionalScript
 
-FunctionalScript is a pure functional programming language and a strict subset of 
-[ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by 
+FunctionalScript is a pure functional programming language and a strict subset of
+[ECMAScript](https://en.wikipedia.org/wiki/ECMAScript)/[JavaScript](https://en.wikipedia.org/wiki/JavaScript). It's inspired by
 
 - [JSON](https://en.wikipedia.org/wiki/JSON) as a subset of JavaScript. JSON is also a subset of FunctionalScript.
 - [asm.JS](https://en.wikipedia.org/wiki/Asm.js)/[WebAssembly](https://en.wikipedia.org/wiki/WebAssembly), as a subset of JavaScript.
 - [TypeScript](https://en.wikipedia.org/wiki/TypeScript), as a superset of JavaScript.
 
+[A brief description of FunctionalScript Programming Language](./LANGUAGE.md).
+
 Create a new FunctionalScript repository on GitHub [here](https://github.com/functionalscript/template/generate).
 
-## 1. Design Principles
+## Design Principles
 
 In FunctionalScript:
 
 - Any module is a valid JavaScript module. No additional build steps are required.
 - Code should not have [side-effects](https://en.wikipedia.org/wiki/Side_effect_(computer_science)). Any JavaScript statement, expression, or function which has a side effect is not allowed in FunctionalScript. There are no exceptions to this rule, such as `unsafe` code which can be found in Rust, C#, and other languages.
-- A module can't depend on non FunctionalScript module. 
+- A module can't depend on non FunctionalScript module.
 - It also has no standard library, only a safe subset of standard JavaScript API can be used without referencing other modules.
-
-## 2. Outlines
-
-### 2.1. Module Ecosystem
-
-FunctionalScript uses [CommonJS](https://en.wikipedia.org/wiki/CommonJS) conventions as a module ecosystem. For example,
-
-```js
-const thirdPartyModule = require('third-party-package/module')
-
-const result = thirdPartyModule.someFunction('hello')
-```
-
-### 2.2. Packages
-
-FunctionalScript uses a `package.json` file to define a package. This file is compatible with [Node.js `package.json`](https://nodejs.org/en/knowledge/getting-started/npm/what-is-the-file-package-json/). 
-The prefered way to refence dependencies is to use a GitHub URL. These dependencies in a `package.json` file could look like this,
-
-```json
-{
-   // ...
-   "dependencies": {
-      "third-party-package": "github:exampleorg/thirdpartypackage"
-   }
-   // ...
-}
-```
-
-**Note:** this repository is also a FunctionalScript package, and it can be used as a library. To install this package, use
-
-```
-npm install -S github:functionalscript/functionalscript
-```
-
-### 2.3. Module Structure
-
-A module is a file with the `.js` extention. It contains three parts: references to other modules, definitions, and exports. For example
-
-`./first.js`
-```js
-// 1. references
-const math = require('math')
-
-// 2. definitions
-const myConst = 42
-// addition(a)(b) = a + b
-const addition = a => b => a + b
-const add42 = addition(42)
-const _10digitsOfPi = math.calculatePi(10)
-
-// 3. exports
-module.exports = {
-   addition,
-   add42,
-   _10digitsOfPi,
-}
-```
-
-`./second.js`
-```js
-// 1. references
-const first = require('./first.js')
-
-// 2. definitions
-const _42plus7 = first.add42(7)
-
-// 3. exports
-module.exports = {
-   _42plus7,
-}
-```
-
-### 2.4. References To Other Modules
-
-The format of references is `const ANYNAME = require('PATH_TO_A_MODULE')`. For example,
-
-```js
-const math = require('math')
-const algebra = require('math/algebra')
-const localFile = require('../some-directory/some-file.js')
-```
-
-### 2.5. Definitions
-
-The format of defintions is `const NAME = EXPRESSION`, where the `EXPRESSION` is a subset of [JavaScript expressions](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators).
-
-```js
-const myConst = 42
-const functionDouble = a => a * 2
-const structure = { name: "John", surname: "Smith" }
-const array = [1, 2, 3]
-const nestedStructure = { 
-   address: undefined, 
-   serialNumber: "123-45-78", 
-   sum: 14 + myConst + functionDouble(4),
-   moreInfo: { 
-      name: "Ivan",
-      surname: "Terrible",
-   } 
-}
-```
-
-See [3. Expressions](#3-Expressions).
-
-### 2.6. Exports
-
-The format of exports is `module.exports = { A_LIST_OF_EXPORTED_DEFINITIONS }`. There should be only one `module.exports` at
-the end of a FunctionalScript file. For example,
-
-```js
-module.exports = {
-   nestedStructure,
-   array,
-   structure,
-}
-```
-
-## 3. Expressions
-
-Expressions could fall under these categories:
-
-- Literals:
-  - Number Literals, e.g. `0`, `3.14`, `4e8`
-  - Boolean Literals: `true` or `false`
-  - A `null` Literal
-  - An `undefined` Literal
-  - String Literals, e.g. `"Hello world!"`
-- Complex Structures
-  - Arrays, e.g. `[2, 5]`
-  - Objects, e.g. `{ a: "Hello", b: "world!" }`
-  - Arrow functions, e.g. `x => x * 2`
-- Operators
-  - Comparison Operators: `===`, `!==`, `>`, `>=`, `<`, `<=`
-  - Arithmetic Operators: `+`, `-`, `*`, `/`, `%`, `**`
-  - Bitwise Operators: `&`, `|`, `^`, `~`, `<<`, `>>`, `>>>`
-  - Logical Operators: `&&`, `||`, `!`, `??`
-  - Conditional Operator, e.g. `condition ? val1 : val2`
-  - Template Literals, e.g. `string ${expression}` 
-  - `typeof`
-  - Relations Operators: `in`, `instanceof`.
-  - Member Operators: `.`, `[]`. 
-    
-Note: the `.` member operator has prohibitted property names, such as `constructor` and `push`. To access such properties, it's recommeded to use the [Object.getOwnPropertyDescriptor](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Reflect/getOwnPropertyDescriptor) function.
-
-## 4. Arrow Functions
-
-An arrow function is also known as [a lambda function](https://en.wikipedia.org/wiki/Anonymous_function).
-The format of an arrow function is `ARGUMENT_NAME => FUNCTION_BODY`. An arrow function must have either a single argument or no arguments at all. For example
-
-```js
-x => x * 2
-a => a + 4
-s => `template literal ${s}`
-a => b => a + b // an arrow functions that returns another arrow functions.
-() => 'hello' // an arrow function with no arguments
-```
-
-A function body is either an expression or a block statement. A block statement format is `{ A_LIST_OF_STATEMENTS }`. For example
-
-```js
-// a function with one argument and a block statement
-const f = x => {
-   const a = 2 + x
-   const r = a + 4
-   return r
-}
-```
-
-## 5. Statements
-
-`{ A_LIST_OF_STATEMENTS }` is one or many statements seperated by the newline control character. One of these statements mentioned earlier was [definition](#25-Definitions), also known as a [const](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/const) statement. The other statements are described below.
-
-### 5.1 Let 
-
-[Let](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/let) declares a local mutable alias for immutable objects. For example
-
-```js
-let x = [5]
-// you can assign another immutable object to the alias at any time.
-x = [3, 4]
-//but you can't change the properties of the immutable object.
-x[0] = 3 // < invalid
-//let aliases can not be referenced from another arrow function.
-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)
-
-### 5.3 If...Else
-
-[If...Else](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/if...else)
-
-### 5.4 Switch
-
-[Switch](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/switch)
-
-### 5.5 Throw
-
-[Throw](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/throw). FunctionalScript allows to throw exceptions but it doesn't catch them. You should only be using Statement throw in non-recoverable situations. It could be compared to [panic in Rust](https://doc.rust-lang.org/std/macro.panic.html).
-
-### 5.6 While
-
-[While](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/while)
-
-### 5.7 Block
-
-[Block](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Statements/block)

package/package.json

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

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,6 @@ 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) {
@@ -353,107 +78,10 @@ const values = node => () => {
 
 /**
  * @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
+ * @typedef { readonly[...Branch5<T>, T, Node<T>] } Branch7
  */
 
-/** @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/test.js

@@ -407,3 +407,81 @@ const jsonStr = json.stringify(sort)
         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,9 +1,11 @@
 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')
@@ -15,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>} */
@@ -49,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 }
 }
 
 {
@@ -58,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>>} */