functionalscript 0.0.168 → 0.0.178

package/btree/index.js

@@ -1,4 +1,6 @@
 const { index3, index5 } = require('../cmp')
+const list = require('../sequence/list')
+const { pipe } = require('../function')
 
 /**
  * @template T
@@ -12,24 +14,24 @@ const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef {import('../array').Array1<T>} Array1
+ * @typedef {import('../sequence/array').Array1<T>} Array1
  */
 
 /**
  * @template T
- * @typedef {import('../array').Array2<T>} Array2
+ * @typedef {import('../sequence/array').Array2<T>} Array2
  */
 
 /**
  * @template T
- * @typedef {import('../array').Array3<T>} Array3
+ * @typedef {import('../sequence/array').Array3<T>} Array3
  */
 
-/** @typedef {import('../array').Index2} Index2 */
+/** @typedef {import('../sequence/array').Index2} Index2 */
 
-/** @typedef {import('../array').Index3} Index3 */
+/** @typedef {import('../sequence/array').Index3} Index3 */
 
-/** @typedef {import('../array').Index5} Index5 */
+/** @typedef {import('../sequence/array').Index5} Index5 */
 
 //
 
@@ -45,17 +47,17 @@ const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef {readonly [TNode<T>, T, TNode<T>]} Branch3
+ * @typedef {readonly [Node<T>, T, Node<T>]} Branch3
  */
 
 /**
  * @template T
- * @typedef {readonly [TNode<T>, T, TNode<T>, T, TNode<T>]} Branch5
+ * @typedef {readonly [Node<T>, T, Node<T>, T, Node<T>]} Branch5
  */
 
 /**
  * @template T
- * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} TNode
+ * @typedef { Leaf1<T> | Leaf2<T> | Branch3<T> | Branch5<T>} Node
  */
 
 /** @typedef {{ readonly done: false }} NotFoundDone */
@@ -75,7 +77,7 @@ const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef {{ readonly replace: TNode<T> }} Replace
+ * @typedef {{ readonly replace: Node<T> }} Replace
  */
 
 /**
@@ -123,7 +125,7 @@ const { index3, index5 } = require('../cmp')
 
 /**
  * @template T
- * @typedef { readonly [TNode<T>, T, TNode<T>, T, TNode<T>, T, TNode<T>] } Branch7
+ * @typedef { readonly [Node<T>, T, Node<T>, T, Node<T>, T, Node<T>] } Branch7
  */
 
 /** @type {<T>(n: Branch7<T>) => Branch3<T>} */
@@ -131,7 +133,7 @@ const split = ([n0, v1, n2, v3, n4, v5, n6]) => [[n0, v1, n2], v3, [n4, v5, n6]]
 
 /** 
  * @type {<T>(overflow: (o: Branch3<T>) => Result<T>) => 
- *  (replace: (r: TNode<T>) => TNode<T>) => 
+ *  (replace: (r: Node<T>) => Node<T>) => 
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
@@ -143,7 +145,7 @@ const merge = overflow => replace => result => {
 
 /** 
  * @type {<T>(overflow: (o: Branch3<T>) => Branch5<T>) => 
- *  (replace: (r: TNode<T>) => Branch3<T>) => 
+ *  (replace: (r: Node<T>) => Branch3<T>) => 
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
@@ -151,19 +153,19 @@ const merge2 = overflow => merge(o => ({ replace: overflow(o) }))
 
 /** 
  * @type {<T>(overflow: (o: Branch3<T>) => Branch7<T>) => 
- *  (replace: (r: TNode<T>) => Branch5<T>) => 
+ *  (replace: (r: Node<T>) => Branch5<T>) => 
  *  (result: Result<T>) => 
  *  Result<T>} 
  */
 const merge3 = overflow => merge(o => ({ overflow: split(overflow(o)) }))
 
-/** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: TNode<T>) => Result<T>} */
+/** @type {(visitor: Visitor) => <T>(cmp: Cmp<T>) => (init: Lazy<T>) => (node: Node<T>) => Result<T>} */
 const visit = ({ found, notFound }) => cmp => {
     const i3 = index3(cmp)
     const i5 = index5(cmp)
     return init => {
         /** @typedef {typeof cmp extends Cmp<infer T> ? T : never} T*/
-        /** @type {(node: TNode<T>) => Result<T>} */
+        /** @type {(node: Node<T>) => Result<T>} */
         const f = node => {
             switch (node.length) {
                 case 1: {
@@ -255,7 +257,7 @@ const notFoundGet = {
     leaf2_right: notFound,
 }
 
-/** @type { <T>(_: TNode<T>) => Replace<T> } */
+/** @type { <T>(_: Node<T>) => Replace<T> } */
 const replace = node => ({ replace: node })
 
 /** @type {Found} */
@@ -304,7 +306,7 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(_: TNode<T>) => Iterable<T>} */
+/** @type {<T>(_: Node<T>) => Iterable<T>} */
 const values = node => ({
     *[Symbol.iterator]() {
         switch (node.length) {
@@ -330,12 +332,43 @@ const values = node => ({
     }
 })
 
+/** @type {<T>(...array: readonly list.List<T>[]) => list.List<T>} */
+const flatArray = (...array) => list.flat(list.fromArray(array))
+
+/** @type {<T>(node: Node<T>) => list.List<T>} */
+const valuesList = node => () => {
+    const f = () => {
+        switch (node.length) {
+            case 1: case 2: { return list.fromArray(node) }
+            case 3: { 
+                return flatArray(
+                    valuesList(node[0]), 
+                    list.one(node[1]), 
+                    valuesList(node[2])
+                )
+            }
+            default: {
+                return flatArray(
+                    valuesList(node[0]),
+                    list.one(node[1]),
+                    valuesList(node[2]),
+                    list.one(node[3]),
+                    valuesList(node[4])
+                )
+            }
+        }
+    }
+    return f()()
+}
+
 module.exports = {
+    /** @readonly */
+    valuesList,
     /** @readonly */
     values,
     /** 
      * @readonly
-     * @type { <T>(cmp: Cmp<T>) => (node: TNode<T>) => T|undefined }
+     * @type { <T>(cmp: Cmp<T>) => (node: Node<T>) => T|undefined }
      */
     getVisitor: cmp => node => {
         const result = visit(getVisitor)(cmp)(() => { throw '' })(node)

package/btree/test.js

@@ -0,0 +1,33 @@
+const btree = require('.')
+const { setVisitor, valuesList } = btree
+const { cmp } = require('../cmp') 
+
+/** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
+const set = node => value => {
+    const result = setVisitor(cmp(value))(() => value)(node)
+    if ('replace' in result) { return result.replace }
+    if ('overflow' in result) { return result.overflow }
+    return node
+}
+
+const test = () => {
+    /** @type {btree.Node<string>} */
+    let node = ['a']
+    node = set(node)('b')
+    node = set(node)('c')
+    node = set(node)('d')
+    node = set(node)('e')
+    node = set(node)('f')
+    //
+    {
+        /** @type {import('../sequence/list').Result<string>} */
+        let result = valuesList(node)()
+        while (result !== undefined) {
+            const t = result[0]
+            console.log(t)
+            result = result[1]()
+        }
+    }
+}
+
+test()

package/cmp/index.js

@@ -1,9 +1,9 @@
-/** @typedef {import('../array').Index3} Index3 */
-/** @typedef {import('../array').Index5} Index5 */
+/** @typedef {import('../sequence/array').Index3} Index3 */
+/** @typedef {import('../sequence/array').Index5} Index5 */
 
 /**
  * @template T
- * @typedef {import('../array').Array2<T>} Array2 
+ * @typedef {import('../sequence/array').Array2<T>} Array2 
  */
 
 /** @typedef {-1|0|1} Sign */
@@ -22,9 +22,14 @@ const index5 = cmp => ([v0, v1]) => {
     return /** @type {Index5} */ (i <= 0 ? i + 1 : cmp(v1) + 3)
 }
 
+/** @type {(a: string) => (b: string) => Sign} */
+const cmp = a => b => a < b ? -1 : a === b ? 0 : 1
+
 module.exports = {
     /** @readonly */
     index3,
     /** @readonly */
     index5,
-}
+    /** @readonly */
+    cmp,
+}

package/function/index.js

@@ -13,21 +13,6 @@ const pipe = g => f => x => f(g(x))
 /** @type {<T>(value: T) => T} */
 const id = value => value
 
-/**
- * @template I
- * @template O
- * @typedef {{
- *  readonly pipe: <R>(f: Func<O, R>) => Pipe<I, R>
- *  readonly call: Func<I, O>
- * }} Pipe
- */
-
-/** @type {<I, O>(f: Func<I, O>) => Pipe<I, O>} */
-const pipex = call => ({
-    pipe: f => pipex(pipe(call)(f)),
-    call,
-}) 
-
 module.exports = {
     /** @readonly */
     id,
@@ -35,6 +20,4 @@ module.exports = {
     pipe,
     /** @readonly */
     combine,
-    /** @readonly */
-    pipex,
 }

package/function/operator/index.js

@@ -0,0 +1,18 @@
+/**
+ * @template R
+ * @template T
+ * @typedef {(prior: R) => (value: T) => R} BinaryOperator
+ */
+
+/** @type {(separator: string) => BinaryOperator<string, string>} */
+const join = separator => prior => value => `${prior}${separator}${value}`
+
+/** @type {(sum: number) => (value: number) => number} */
+const addition = a => b => a + b
+
+module.exports = {
+    /** @readonly */
+    join,
+    /** @readonly */
+    addition,
+}

package/map/index.js

@@ -1,5 +1,6 @@
 const option = require("../option")
 const { getVisitor, setVisitor, values } = require("../btree")
+const { cmp } = require("../cmp")
 
 /** @typedef {import("../cmp").Sign} Sign */
 
@@ -10,7 +11,7 @@ const { getVisitor, setVisitor, values } = require("../btree")
 
 /**
  * @template T
- * @typedef {import("../btree").TNode<T>} TNode
+ * @typedef {import("../btree").Node<T>} TNode
  */
 
 /**
@@ -34,13 +35,13 @@ const { getVisitor, setVisitor, values } = require("../btree")
  */
 
 /** @type {(a: string) => <T>(b: Entry<T>) => Sign} */
-const cmp = a => ([b]) => a < b ? -1 : a === b ? 0 : 1
+const keyCmp = a => ([b]) => cmp(a)(b)
 
 /** @type {<T>(node: TNode<Entry<T>>) => Map<T>} */
 const create = root => ({
-    get: name => option.map(([,value]) => value)(getVisitor(cmp(name))(root)),
+    get: name => option.map(([,value]) => value)(getVisitor(keyCmp(name))(root)),
     set: name => value => {
-        const result = setVisitor(cmp(name))(() => [name, value])(root)
+        const result = setVisitor(keyCmp(name))(() => [name, value])(root)
         if ('replace' in result) { return create(result.replace) }
         if ('overflow' in result) { return create(result.overflow) }
         throw ''

package/module-manager/index.js

@@ -1,8 +1,9 @@
-const array = require('../array')
+const array = require('../sequence/array')
 const { pipe } = require('../function')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
-const iter = require('../iterable')
+const iter = require('../sequence/iterable')
+const seq = require('../sequence')
 
 /**
  * @template T
@@ -38,24 +39,22 @@ const iter = require('../iterable')
 
 /** @typedef {(_: string) => undefined|Package|Dependencies} Dependencies */
 
-/** @type {import('../sequence').Operation<string, undefined|Path, undefined|Path>} */
-const pathNormReduce = {
-    merge: path => item =>
+/** @type {seq.InclusiveScan<string, undefined|Path>} */
+const pathNormReduce = seq.inclusiveScan
+    (path => item =>
         path === undefined ?
             undefined :
         ['', '.'].includes(item) ?
             path :
         item === '..' ?
             head(path) :
-            [...path, item],
-    init: [],
-    result: s => s,
-}
+            [...path, item])
+    ([])
 
 /** @type {(_: Array<string>) => boolean} */
 const isRelative = localId => ['.', '..'].includes(localId[0])
 
-const pathNorm = iter.apply(pathNormReduce)
+const pathNorm = iter.reduce(pathNormReduce)
 
 /** @type {(_: Package) => (_: Path) => Module|undefined} */
 const internal = pack => {

package/option/index.js

@@ -3,10 +3,15 @@
  * @typedef {T|undefined} Option
  */
 
-/** @type {<T, R>(_: (_: T) => R) => (_: T|undefined) => R|undefined} */
-const map = f => x => x === undefined ? undefined : f(x)
+/** @type {<T, R>(f: (value: T) => R) => (value: T|undefined) => R|undefined} */
+const map = f => value => value === undefined ? undefined : f(value)
+
+/** @type {<T, R>(f: (_: T) => R) => (none: () => R) => (_: T|undefined) => R|undefined} */
+const match = f => none => value => value === undefined ? none() : f(value)
 
 module.exports = {
     /** @readonly */
     map,
+    /** @readonly */
+    match,
 }

package/package.json

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

package/sequence/README.md

@@ -0,0 +1,53 @@
+# Sequences
+
+Sequence types:
+
+- Array
+- List
+- Iterable
+- AsyncIterable
+
+## Functions
+
+See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
+
+- `length: Sequence<infer T> => number`
+- `at: number => Sequence<infer T> = T`
+- `concat: Sequence<infer T> => Sequence<T> => Sequence<T>`
+- `entries: Sequence<infer T> => Sequence<[number, T]>`
+- `every: (infer T => boolean) => Sequence<T> => boolean`
+- `filter: (infer T => boolean) => Sequence<T> => Sequence<T>`
+- `find: (infer T => boolean) => Sequence<T> => T`
+- `findIndex: (infer T => boolean) => Sequence<T> => number`
+- `flat: Sequence<Sequence<T>> => Sequence<T>`
+- `flatMap: (infer T => Sequence<infer R>) => Sequence<T> => Sequence<R>`
+- `includes: infer T => Sequence<T> => boolean`
+- `indexOf: infer T => Sequence<T> => number`
+- `join: string => Sequence<string> => string`
+- `keys: Sequence<T> => Sequence<string>`
+- `lastIndexOf: infer T => Sequence<T> => number`
+- `map: (infer T => infer R) => Sequence<T> => Sequence<R>`
+- `reduce: ...Scan<T, R> => Sequence<T> => R`
+- `some: (infer T => boolean) => Sequence<T> => boolean`
+
+### Priority 2.
+
+- `slice: number => number => Sequence<T> => Sequence<T>`
+- `reduceRight: ...Scan<T, R> => Sequence<T> => R`
+- `toLocalString: Locales => Sequence<T> => string`
+
+### Priority 3.
+
+- `values: Sequence<infer T> => Sequence<T>`
+
+## Prohibited Array Operations
+
+- `copyWithin`
+- `fill`
+- `pop`
+- `push`
+- `reverse`
+- `shift`
+- `sort`
+- `splice`
+- `unshift`

package/{array → sequence/array}/index.js

@@ -1,4 +1,4 @@
-const option = require('../option')
+const option = require('../../option')
 
 /**
  * @template T
@@ -44,6 +44,11 @@ const option = require('../option')
  * @typedef {readonly [T, T, T, T, T]} Array5
  */
 
+/**
+ * @template T
+ * @typedef {Array1<T>| Array2<T> | Array3<T> | Array4<T> | Array5<T>} Array1_5
+ */
+
 /** @typedef {0|1|2|3|4} Index5 */
 
 /** @type {<T>(_: Array<T>) => Array<T>} */
@@ -80,7 +85,12 @@ const splitLast = a => {
     return option.map(split)(last(a))
 }
 
+/** @type {(index: number) => <T>(a: Array<T>) => readonly[T]|undefined} */
+const at = index => a => index < a.length ? [a[index]] : undefined
+
 module.exports = {
+    /** @readonly */
+    at,
     /** @readnly */
     first,
     /** @readonly */

package/sequence/asyncIterable/index.js

@@ -0,0 +1,111 @@
+const { pipe } = require('../../function')
+const seq = require('..')
+
+/**
+ * @template T 
+ * @typedef {Promise<T>|T} PromiseOrValue 
+ */
+
+/**
+ * @template T
+ * @typedef {Iterable<T> | AsyncIterable<T>} AsyncOrSyncIterable
+ */
+
+/** @type {<T>(c: AsyncOrSyncIterable<AsyncOrSyncIterable<T>>) => AsyncIterable<T>} */
+const flat = c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield* i
+        }
+    }
+})
+
+/** @type {<T, R>(f: (value: T) => AsyncOrSyncIterable<R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
+const flatMap = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            yield* await f(i)
+        }
+    }
+})
+
+/** @type {<T, R>(f: (value: T) => R) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
+const map = seq.map(flatMap)
+
+/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncOrSyncIterable<T>} */
+const filter = seq.filter(flatMap)
+
+/** @type {<T>(a: AsyncOrSyncIterable<T>) => (b: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
+const concat = a => b => ({
+    async *[Symbol.asyncIterator]() {
+        yield* a
+        yield* b
+    }
+})
+
+/** @type {<T, R>(s: seq.Scan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
+const scan = s => c => ({
+    async *[Symbol.asyncIterator]() {
+        let next = s
+        for await (const i of c) {
+            const result = next(i)
+            next = result[1]
+            yield result[0]
+        }
+    }
+})
+
+/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<R>} */
+const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
+
+/** @type {<T, R>(is: seq.InclusiveScan<T, R>) => (c: AsyncOrSyncIterable<T>) => Promise<R>} */
+const reduce = ([first, s]) => async c => {
+    let next = first
+    for await (const i of scan(s)(c)) {
+        next = i
+    }
+    return next
+}
+
+const sum = reduce(seq.sum)
+
+const join = pipe(seq.join)(reduce)
+
+const length = reduce(seq.length)
+
+/** @type {<T>(f: (value: T) => boolean) => (c: AsyncOrSyncIterable<T>) => AsyncIterable<T>} */
+const takeWhile = f => c => ({
+    async *[Symbol.asyncIterator]() {
+        for await (const i of c) {
+            if (!f(i)) { return }
+            yield i
+        }
+    }
+})
+
+module.exports = {
+    /** @readonly */
+    concat,
+    /** @readonly */
+    flat,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    length,
+    /** @readonly */
+    join,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    inclusiveScan,
+    /** @readonly */
+    takeWhile,
+}

package/{async/iterable → sequence/asyncIterable}/test.js

@@ -3,13 +3,13 @@ const { map, filter, flatMap, sum } = require('.')
 const test = async () => {
     {
         const a = [1, 2, 3]
-        const m = map(async x => x * x)(a)
+        const m = map(x => x * x)(a)
         const result = await sum(m)
         if (result !== 14) { throw 'filter' }
     }
     {
         const a = [1, 2, 3, 4]
-        const f = filter(async x => x !== 2)(a)
+        const f = filter(x => x !== 2)(a)
         const result = await sum(f)
         if (result !== 8) { throw 'filter' }
     }

package/sequence/index.js

@@ -1,10 +1,10 @@
-const { todo } = require('../dev')
+const op = require('../function/operator')
 const { id } = require('../function')
 
 /**
  * @template T0
  * @template T1
- * @typedef {import('../array').Tuple2<T0, T1>} Tuple2
+ * @typedef {import('./array').Tuple2<T0, T1>} Tuple2
  */
 
 /**
@@ -22,21 +22,12 @@ const { id } = require('../function')
 /**
  * @template T
  * @template R
- * @typedef {{
- *  readonly scan: Scan<T, R>
- *  readonly first: R
- * }} InclusiveScan
+ * @typedef {Tuple2<R, Scan<T, R>>} InclusiveScan
  */
 
-/**
- * @template R
- * @template T
- * @typedef {(prior: R) => (value: T) => R} BinaryOperator
- */
-
-/** @type {<R, T>(operator: BinaryOperator<R, T>) => (prior: R) => Scan<T, R>} */
-const operatorScan = operator => {
-    /** @typedef {typeof operator extends BinaryOperator<infer R, infer T> ? [R, T] : never} RT */
+/** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (prior: R) => Scan<T, R>} */
+const scan = operator => {
+    /** @typedef {typeof operator extends op.BinaryOperator<infer R, infer T> ? [R, T] : never} RT */
     /** @typedef {RT[0]} R */
     /** @typedef {RT[1]} T */
     /** @type {(prior: R) => Scan<T, R>} */
@@ -47,11 +38,8 @@ const operatorScan = operator => {
     return f
 } 
 
-/** @type {<R, T>(operator: BinaryOperator<R, T>) => (first: R) => InclusiveScan<T, R>} */
-const inclusiveOperatorScan = operator => first => ({
-    scan: operatorScan(operator)(first),
-    first,
-})
+/** @type {<R, T>(operator: op.BinaryOperator<R, T>) => (first: R) => InclusiveScan<T, R>} */
+const inclusiveScan = operator => first => [first, scan(operator)(first)]
 
 /** 
  * @template T
@@ -63,69 +51,40 @@ const createEntries = index => value => [[index, value], createEntries(index + 1
 
 const entries = createEntries(0)
 
-/** @type {(separator: string) => BinaryOperator<string, string>} */
-const joinOperation = separator => prior => value => `${prior}${separator}${value}`
-
 /** @type {(separator: string) => InclusiveScan<string, string>} */
-const join2 = separator => ({
-    scan: value => [value, operatorScan(joinOperation(separator))(value)],
-    first: ''
-})
-
-/** @type {(sum: number) => (value: number) => number} */
-const addition = a => b => a + b
+const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
 
-/** @type {InclusiveScan<number, number>} */
-const sum2 = inclusiveOperatorScan(addition)(0)
+const sum = inclusiveScan(op.addition)(0)
 
-////
+const length = inclusiveScan(a => () => a + 1)(0)
 
 /**
- * @template I
- * @template S
- * @template O
- * @typedef {{
- *  readonly merge: BinaryOperator<S, I>
- *  readonly result: (state: S) => O
- *  readonly init: S
- * }} Operation
+ * @template T
+ * @template R
+ * @typedef {(value: T) => R} Func
  */
 
-/** @type {(separator: string) => Operation<string, string|undefined, string>} */
-const join = separator => ({ 
-    merge: s => i => s === undefined ? i : `${s}${separator}${i}`, 
-    init: undefined,
-    result: s => s === undefined ? '' : s
-})
-
-/** @type {Operation<number, number, number>} */
-const sum = { 
-    merge: a => i => a + i, 
-    result: id,
-    init: 0,
-}
+/** @type {<T, R, X>(flatMap: (f: Func<T, readonly[R]>) => X) => (f: Func<T, R>) =>X} */
+const map = flatMap => f => flatMap(x => [f(x)])
 
-/**
- * @type {{
- *  readonly merge: (counter: number) => () => number
- *  readonly result: (counter: number) => number
- *  readonly init: number
- * }}
- */
-const size = {
-    merge: counter => () => counter + 1,
-    init: 0,
-    result: id,
-}
+/** @type {<T, X>(flatMap: (f: Func<T, readonly[T]|[]>) => X) => (f: Func<T, boolean>) =>X} */
+const filter = flatMap => f => flatMap(x => f(x) ? [x] : [])
 
 module.exports = {
+    /** @readonly */
+    inclusiveScan,
+    /** @readonly */
+    scan,
     /** @readonly */
     join,
-    join2,
     /** @readonly */
     sum,
     /** @readonly */
-    size,
+    length,
     /** @readonly */
     entries,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
 }

package/sequence/iterable/index.js

@@ -0,0 +1,109 @@
+const { pipe } = require('../../function')
+const seq = require('..')
+
+/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
+const concat = a => b => ({
+    *[Symbol.iterator]() {
+        yield* a
+        yield* b
+    }
+})
+
+/** @type {<T, R>(s: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const scan = s => c => ({
+    *[Symbol.iterator]() {
+        let next = s
+        for (const i of c) {
+            const result = next(i)
+            next = result[1]
+            yield result[0]
+        }
+    }
+})
+
+/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
+const inclusiveScan = ([first, s]) => c => concat([first])(scan(s)(c))
+
+/** @type {<T, R>(s: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => R} */
+const reduce = ([first, s]) => c => {
+    let next = first
+    for (const i of scan(s)(c)) {
+        next = i
+    }
+    return next
+}
+
+const entries = scan(seq.entries)
+
+const sum = reduce(seq.sum)
+
+const length = reduce(seq.length)
+
+const join = pipe(seq.join)(reduce)
+
+/** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
+const flatMap = f => c => ({
+    *[Symbol.iterator]() {
+        for (const i of c) {
+            yield* f(i)
+        }
+    }
+})
+
+/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
+const map = seq.map(flatMap)
+
+/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
+const filter = seq.filter(flatMap)
+
+/** @type {<T>(c: Iterable<Iterable<T>>) => Iterable<T>} */
+const flat = flatMap(x => x)
+
+/** @type {<T>(f: (value: T) => boolean) => (c: Iterable<T>) => Iterable<T>} */
+const takeWhile = f => c => ({
+    *[Symbol.iterator]() {
+        for (const i of c) {
+            if (!f(i)) { return }
+            yield i
+        }
+    }
+})
+
+/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
+const find = f => c => {
+    for (const i of c) {
+        if (f(i)) {
+            return i
+        }
+    }
+    return undefined
+}
+
+module.exports = {
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    join,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    length,
+    /** @readonly */
+    entries,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    inclusiveScan,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    flat,
+    /** @readonly */
+    takeWhile,
+    /** @readonly */
+    find,
+}

package/{iterable → sequence/iterable}/test.js

@@ -1,5 +1,5 @@
 const i = require('.')
-const { pipe } = require('../function')
+const { pipe } = require('../../function')
 
 {
     const r = i.sum([120, 300, 42])

package/sequence/list/index.js

@@ -0,0 +1,194 @@
+const array = require('../array')
+const option = require('../../option')
+const base = require('..')
+const { pipe } = require('../../function')
+const { todo } = require('../../dev')
+
+/**
+ * @template T
+ * @typedef {() => Result<T>} List
+ */
+
+/**
+ * @template T
+ * @typedef {FirstAndTail<T>|undefined} Result<T>
+ */
+
+/**
+ * @template T
+ * @typedef {array.Tuple2<T, List<T>>} FirstAndTail
+ */
+
+const empty = () => undefined
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(list: List<T>) => List<R>} ListMap
+ */
+
+/** @type {<T>(first: T) => ListMap<T, T>} */
+const list = first => tail => () => [first, tail]
+
+/** @type {<T>(first: T) => List<T>} */
+const one = first => list(first)(empty)
+
+/** @type {<T>(array: array.Array<T>) => List<T>} */
+const fromArray = a => {
+    /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
+    /** @type {(index: number) => List<T>} */
+    const at = index => {
+        /** @type {(value: readonly [T]) => Result<T>} */
+        const result = ([value]) => list(value)(at(index + 1))()
+        return () => option.map(result)(array.at(index)(a))
+    }
+    return at(0)
+}
+
+/**
+ * Note: the function is not completly lazy.
+ *       it calls `a()` as soon as `a` and `b` are provided.
+ *       Othrewise we may have a stack overflow if a list 
+ *       contains a lot of concateneted empty lists.
+ *       And we can't relay on ES6 TCO (Tail Call Optimization) 
+ *       because it's not supported by Chrome and Firefox.
+ * @type {<T>(list0: List<T>) => ListMap<T, T>} 
+ */
+const concat = a => b => {
+    const result = a()
+    if (result !== undefined) {
+        const [first, tail] = result
+        return () => [first, concat(tail)(b)]
+    }
+    return b
+    // /** @typedef {typeof a extends List<infer T> ? T : never} T */
+    // /** @type {(firstAntTail: FirstAndTail<T>) => Result<T>} */
+    // const defined = ([first, tail]) => [first, concat(tail)(b)]
+    // return option.match(defined)(b)(a())
+}
+
+/** @type {<T, R>(f: (value: T) => List<R>) => ListMap<T, R>} */
+const flatMap = f => input => () => {
+    let i = input
+    while (true) { 
+        const result = i()
+        if (result === undefined) { return undefined }
+        const [first, tail] = result
+        const firstResult = f(first)() 
+        if (firstResult !== undefined) {
+            const [firstFirst, firstTail] = firstResult
+            return [firstFirst, concat(firstTail)(flatMap(f)(tail))]
+        }
+        i = tail
+    }
+}
+
+/** @type {<T>(list: List<List<T>>) => List<T>} */
+const flat = flatMap(i => i)
+
+/** @type {<T, R>(f: (value: T) => R) => ListMap<T, R>} */
+const map = f => flatMap(i => one(f(i)))
+
+/** @type {<T>(f: (value: T) => boolean) => ListMap<T, T>} */
+const filter = f => flatMap(i => f(i) ? one(i) : empty)
+
+/** @type {<T, R>(s: base.Scan<T, R>) => ListMap<T, R>} */
+const scan = s => input => () => {
+    /** @typedef {typeof s extends base.Scan<infer T, infer R> ? [T, R] : never} TR */
+    /** @typedef {TR[0]} T */
+    /** @typedef {TR[1]} R */
+    /** @type {(firstAndTail: FirstAndTail<T>) => Result<R>} */
+    const defined = ([first, tail]) => {
+        const [newFirst, newS] = s(first)
+        return [newFirst, scan(newS)(tail)]
+    }
+    return option.map(defined)(input())
+}
+
+/** @type {<T, R>(s: base.InclusiveScan<T, R>) => ListMap<T, R>} */
+const inclusiveScan = ([first, s]) => input => list(first)(scan(s)(input))
+
+/** @type {<T>(def: T) => (input: List<T>) => T} */
+const last = def => input => {
+    let i = input()
+    let r = def
+    while (i !== undefined) {
+        r = i[0]
+        i = i[1]()
+    }
+    return r
+}
+
+/** @type {<T, R>(s: base.InclusiveScan<T, R>) => (input: List<T>) => R} */
+const reduce = s => input => last(s[0])(inclusiveScan(s)(input))
+
+const entries = scan(base.entries)
+
+const sum = reduce(base.sum)
+
+const length = reduce(base.length)
+
+const join = pipe(base.join)(reduce)
+
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => T|undefined} */
+const find = f => input => {
+    /** @typedef {typeof f extends (value: infer T) => boolean ? T : never} T */
+    /** @type {(result: FirstAndTail<T>) => T} */
+    const defined = ([first]) => first
+    return option.map(defined)(filter(f)(input)())
+}
+
+/**
+ * Note: probably, it's possible to implement using the `scan` concept.
+ * @type {<T>(list: List<T>) => Iterable<T>} 
+ */
+const iterable = list => ({
+    *[Symbol.iterator]() {
+        let result = list()
+        while (result !== undefined) {
+            yield result[0]
+            result = result[1]()
+        }
+    }
+})
+
+module.exports = {
+    /** @readonly */
+    list,
+    /** @readonly */
+    one,
+    /** @readonly */
+    empty,
+    /** @readonly */
+    concat,
+    /** @readonly */
+    fromArray,
+    /** @readonly */
+    iterable,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    flat,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    inclusiveScan,
+    /** @readonly */
+    last,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    entries,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    join,
+    /** @readonly */
+    length,
+    /** @readonly */
+    find,
+}

package/sequence/list/test.js

@@ -0,0 +1,36 @@
+const list = require('.')
+const { sum } = require('..')
+
+/** @type {<T>(l: list.List<T>) => void} */
+const print = a => {
+    let i = a()
+    while (i !== undefined) {
+        console.log(i[0])
+        i = i[1]()
+    }
+}
+
+{
+    const big = list.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
+    const list0 = list.fromArray([0, 1, 2, 3])
+    const list1 = list.flatMap(x => list.fromArray([x, x * 2, x * 3]))(list0)
+    const list2 = list.concat(list0)(list0)
+    const list3 = list.inclusiveScan(sum)(list0)
+    const r = list.find(x => x === 42)(big)
+    {
+        let x = big
+        for (let i = 0; i < 10000; ++i) {
+            x = list.concat(list.empty)(x)
+        }
+        const r = x()
+        print(x)
+    } 
+    {
+        let x = big
+        for (let i = 0; i < 10000; ++i) {
+            x = list.concat(x)(list.empty)
+        }
+        const r = x()
+        print(x)
+    }
+}

package/test.js

@@ -1,7 +1,9 @@
 const i = require('./')
 
-require('./iterable/test')
-require('./async/iterable/test')
+require('./sequence/list/test')
+require('./btree/test')
+require('./sequence/iterable/test')
+require('./sequence/asyncIterable/test')
 require('./module-manager/test')
 
 /** @type {() => never} */

package/async/iterable/index.js

@@ -1,133 +0,0 @@
-const { pipe } = require('../../function')
-const seq = require('../../sequence')
-
-/** 
- * @template T
- * @typedef {Promise<T>|T} PromiseOrValue
- */
-
-/** 
- * @template T
- * @template R
- * @typedef {(f: (value: T) => PromiseOrValue<R>) => (c: AsyncIterable<T>) => AsyncIterable<R>} Map
- */
-
-/**
- * @template T
- * @typedef {Iterable<T> | AsyncIterable<T>} AnyIterable
- */
-
-/** @type {<T, R>(f: (value: T) => PromiseOrValue<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
-const map = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield f(i)
-        }
-    }
-})
-
-/** @type {<T>(c: AnyIterable<AnyIterable<T>>) => AsyncIterable<T>} */
-const flatten = c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            yield *i
-        }
-    }
-})
-
-/** @type {<T>(f: (value: T) => Promise<boolean>) => (c: AnyIterable<T>) => AnyIterable<T>} */
-const filter = f => c => ({
-    async *[Symbol.asyncIterator]() {
-        for await (const i of c) {
-            if (await f(i)) {
-                yield i
-            }
-        }
-    }
-})
-
-/** @type {<T, R>(f: (value: T) => AnyIterable<R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
-const flatMap = f => pipe(map(f))(flatten)
-
-/** 
- * @template A
- * @template T
- * @typedef {(accumulator: A) => (value: T) => PromiseOrValue<A>} Merge
- */
-
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => Promise<A>} */
-const reduce = merge => init => async c => {
-    let result = init
-    for await (const i of c) {
-        result = await merge(result)(i)
-    }
-    return result
-}
-
-/** @type {<T>(a: AnyIterable<T>) => (b: AnyIterable<T>) => AsyncIterable<T>} */
-const concat = a => b => ({
-    async *[Symbol.asyncIterator]() {
-        yield* a
-        yield* b
-    }
-})
-
-/** @type {<A, T>(merg: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => AsyncIterable<A>} */
-const exclusiveScan = merge => init => c => ({
-    async *[Symbol.asyncIterator]() {
-        let result = init
-        for await (const i of c) {
-            result = await merge(result)(i)
-            yield result
-        }
-    }
-})
-
-/** @type {<T, R>(es: seq.Scan<T, R>) => (c: AnyIterable<T>) => AsyncIterable<R>} */
-const applyExclusiveScan = es => c => ({
-    async *[Symbol.asyncIterator]() {
-        let ies = es
-        for await (const i of c) {
-            const result = ies(i)
-            ies = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: AnyIterable<T>) => AsyncIterable<A>} */
-const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
-
-/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: AnyIterable<I>) => Promise<R>} */
-const apply = ({ merge, init, result }) => async c => result(await reduce(merge)(init)(c))
-
-const sum = apply(seq.sum)
-
-const join = pipe(seq.join)(apply)
-
-const size = apply(seq.size)
-
-module.exports = {
-    /** @readonly */
-    apply,
-    /** @readonly */
-    concat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    size,
-    /** @readonly */
-    join,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    inclusiveScan,
-}

package/iterable/index.js

@@ -1,116 +0,0 @@
-const { pipe } = require('../function')
-const seq = require('../sequence')
-
-/**
- * @template S
- * @template T
- * @typedef {(_: S) => (_: T) => S} Merge
- */
-
-/** @type {<T, R>(merge: Merge<R, T>) => (init: R) => (_: Iterable<T>) => R} */
-const reduce = merge => init => c => {
-    let result = init
-    for (const i of c) {
-        result = merge(result)(i)
-    }
-    return result
-}
-
-/** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
-const concat = a => b => ({
-    *[Symbol.iterator]() {
-        yield *a
-        yield *b
-    }
-})
-
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
-const exclusiveScan = merge => init => c => ({
-    *[Symbol.iterator]() {
-        let result = init
-        for (const i of c) {
-            result = merge(result)(i)
-            yield result
-        }
-    }
-})
-
-/** @type {<A, T>(merge: Merge<A, T>) => (init: A) => (c: Iterable<T>) => Iterable<A>} */
-const inclusiveScan = merge => init => c => concat([init])(exclusiveScan(merge)(init)(c))
-
-/** @type {<T, R>(es: seq.Scan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const applyScan = es => c => ({
-    *[Symbol.iterator]() {
-        let ies = es
-        for (const i of c) {
-            const result = ies(i)
-            ies = result[1]
-            yield result[0]
-        }
-    }
-})
-
-/** @type {<T, R>(is: seq.InclusiveScan<T, R>) => (c: Iterable<T>) => Iterable<R>} */
-const applyInclusiveScan = ({scan, first}) => c => concat([first])(applyScan(scan)(c))
-
-const entries = applyScan(seq.entries)
-
-/** @type {<I, S, R>(op: seq.Operation<I, S, R>) => (_: Iterable<I>) => R} */
-const apply = ({ merge, init, result }) => pipe(reduce(merge)(init))(result)
-
-const sum = apply(seq.sum)
-
-const size = apply(seq.size)
-
-const join = pipe(seq.join)(apply)
-
-/** @type {<T, R>(f: (value: T) => R) => (c: Iterable<T>) => Iterable<R>} */
-const map = f => c => ({
-    *[Symbol.iterator]() {
-        for (const i of c) {
-            yield f(i)
-        }
-    }
-})
-
-/** @type {<T>(_: (_: T) => boolean) => (_: Iterable<T>) => T|undefined} */
-const find = f => c => {
-    for (const i of c) {
-        if (f(i)) {
-            return i
-        }
-    }
-    return undefined
-}
-
-module.exports = {
-    /** @readonly */
-    apply,
-
-    /** @readonly */
-    reduce,
-
-    /** @readonly */
-    join,
-
-    /** @readonly */
-    sum,
-
-    /** @readonly */
-    size,
-
-    /** @readonly */
-    entries,
-
-    /** @readonly */
-    map,
-
-    /** @readonly */
-    exclusiveScan,
-
-    /** @readonly */
-    inclusiveScan,
-
-    /** @readonly */
-    find,
-}