functionalscript 0.0.185 → 0.0.191

package/btree/index.js

@@ -1,6 +1,5 @@
 const { index3, index5 } = require('../cmp')
-const list = require('../sequence/list')
-const { pipe } = require('../function')
+const seq = require('../sequence')
 
 /**
  * @template T
@@ -306,64 +305,33 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(_: Node<T>) => Iterable<T>} */
-const values = node => ({
-    *[Symbol.iterator]() {
-        switch (node.length) {
-            case 1: case 2: {
-                yield* node
-                return
-            }
-            case 3: {
-                yield* values(node[0])
-                yield node[1]
-                yield* values(node[2])
-                return
-            }
-            default: {
-                yield* values(node[0])
-                yield node[1]
-                yield* values(node[2])
-                yield node[3]
-                yield* values(node[4])
-                return
-            }
-        }
-    }
-})
-
-/** @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 => () => {
+/** @type {<T>(node: Node<T>) => seq.Sequence<T>} */
+const values = node => () => {
     const f = () => {
         switch (node.length) {
-            case 1: case 2: { return list.fromArray(node) }
+            case 1: case 2: { return seq.list(...node) }
             case 3: { 
-                return flatArray(
-                    valuesList(node[0]), 
-                    list.one(node[1]), 
-                    valuesList(node[2])
+                return seq.concat(
+                    values(node[0]), 
+                    seq.list(node[1]), 
+                    values(node[2])
                 )
             }
             default: {
-                return flatArray(
-                    valuesList(node[0]),
-                    list.one(node[1]),
-                    valuesList(node[2]),
-                    list.one(node[3]),
-                    valuesList(node[4])
+                return seq.concat(
+                    values(node[0]),
+                    seq.list(node[1]),
+                    values(node[2]),
+                    seq.list(node[3]),
+                    values(node[4])
                 )
             }
         }
     }
-    return list.next(f())
+    return seq.next(f())
 }
 
 module.exports = {
-    /** @readonly */
-    valuesList,
     /** @readonly */
     values,
     /** 

package/btree/test.js

@@ -1,7 +1,7 @@
 const btree = require('.')
-const { setVisitor, valuesList } = btree
+const { setVisitor, values: valuesList } = btree
 const { cmp } = require('../cmp') 
-const list = require('../sequence/list')
+const list = require('../sequence')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
@@ -21,11 +21,9 @@ const test = () => {
     node = set(node)('f')
     //
     {
-        /** @type {import('../sequence/list').Result<string>} */
+        /** @type {import('../sequence').Result<string>} */
         let result = list.next(valuesList(node))
         while (result !== undefined) {
-            const t = result[0]
-            console.log(t)
             result = list.next(result[1])
         }
     }

package/json/index.js

@@ -0,0 +1,89 @@
+const seq = require('../sequence')
+const map = require('../map')
+const op = require('../sequence/operator')
+
+/** 
+ * @typedef {{
+ *  readonly [k in string]: Json
+ * }} Object 
+ */
+
+/** @typedef {readonly Json[]} Array */
+
+/** @typedef {Object|boolean|string|number|null|Array} Json */
+
+/** @type {(value: Json) => (path: readonly string[]) => (src: Json|undefined) => Json} */
+const addProperty = value => {
+    /** @type {(path: seq.Sequence<string>) => (src: Json|undefined) => Json} */
+    const f = path => src => {
+        const result = seq.next(path)
+        if (result === undefined) { return value }
+        const srcObject = (src === undefined || src === null || typeof src !== 'object' || src instanceof Array) ? {} : src
+        const [name, tail] = result
+        return { ...srcObject, [name]: f(tail)(srcObject[name]) }
+    }
+    return path => f(seq.fromArray(path))
+}
+
+/** @type {(kv: readonly[string, seq.Sequence<string>]) => seq.Sequence<string>} */
+const property = ([k, v]) => seq.concat(seq.list(JSON.stringify(k)), seq.list(':'), v)
+
+/** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
+const commaValue = a => [seq.concat(seq.list(','), a), commaValue]
+
+/** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
+const joinScan = value => [value, commaValue]
+
+/** @type {seq.SequenceMap<seq.Sequence<string>, string>} */
+const join = input => seq.flat(seq.scan(joinScan)(input))
+
+/** @type {(open: string) => (close: string) => (input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+const list = open => close => {
+    const seqOpen = seq.list(open)
+    const seqClose = seq.list(close)
+    return input => seq.concat(seqOpen, join(input), seqClose)
+}
+
+const objectList = list('{')('}')
+
+const arrayList = list('[')(']')
+
+/** @type {(object: Object) => seq.Sequence<string>} */
+const objectStringify = object => {
+    /** @type {map.Map<seq.Sequence<string>>} */
+    const m = seq.fold(m => ([k, v]) => m.set(k)(stringSeq(v)))(map.empty)(seq.fromArray(Object.entries(object)))
+    return objectList(seq.map(property)(m.entries))
+}
+
+/** @type {(array: Array) => seq.Sequence<string>} */
+const arrayStringify = array => arrayList(seq.map(stringSeq)(seq.fromArray(array)))
+
+/** @type {(value: Json) => seq.Sequence<string>} */
+const stringSeq = value => {
+    const x = typeof value
+    switch (typeof value) {
+        case 'boolean': { return seq.list(value ? "true" : "false") }
+        // Note: we shouldn't use JSON.stringify since it has non determenistic behavior.
+        // In particular: property order could be different.
+        case 'number': case 'string': { return seq.list(JSON.stringify(value)) }
+        default: {
+            if (value === null) { return seq.list("null") }
+            if (value instanceof Array) { return arrayStringify(value) }
+            return objectStringify(value)
+        }
+    }
+}
+
+/**
+ * A deterministic version of `JSON.stringify`
+ *  
+ * @type {(value: Json) => string} 
+ */
+const stringify = value => seq.join('')(stringSeq(value))
+
+module.exports = {
+    /** @readonly */
+    addProperty,
+    /** @readonly */
+    stringify,
+}

package/json/test.js

@@ -0,0 +1,18 @@
+const json = require('.')
+
+if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
+
+{
+    const x = json.stringify(json.addProperty("Hello")(['a'])({}))
+    if (x !== '{"a":"Hello"}') { throw x }
+}
+
+{
+    const x = json.stringify(json.addProperty("Hello")(['a'])({c:[],b:12}))
+    if (x !== '{"a":"Hello","b":12,"c":[]}') { throw x }
+}
+
+{
+    const x = json.stringify(json.addProperty("Hello")(['a', 'x'])({ a: { y: [24] }, c: [], b: 12 }))
+    if (x !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') { throw x }
+}

package/map/index.js

@@ -1,7 +1,8 @@
 const option = require("../option")
-const { getVisitor, setVisitor, valuesList } = require("../btree")
+const { getVisitor, setVisitor, values: valuesList } = require("../btree")
 const { cmp } = require("../cmp")
-const list = require("../sequence/list")
+const seq = require("../sequence")
+const op = require("../sequence/operator")
 
 /** @typedef {import("../cmp").Sign} Sign */
 
@@ -30,7 +31,7 @@ const list = require("../sequence/list")
  * @typedef {{
  *  readonly get: (name: string) => T|undefined
  *  readonly set: (name: string) => (value: T) => Map<T> 
- *  readonly entries: list.List<Entry<T>>
+ *  readonly entries: seq.Sequence<Entry<T>>
  *  readonly root: undefined|TNode<Entry<T>>
  * }} Map
  */
@@ -62,11 +63,16 @@ const create = root => ({
 const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
-    entries: list.empty,
+    entries: seq.empty,
     root: undefined
 }
 
+/** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
+const fromEntries = seq.fold(map => entry => map.set(entry))(empty)
+
 module.exports = {
     /** @readonly */
     empty,
+    /** @readonly */
+    fromEntries,
 }

package/map/test.js

@@ -1,5 +1,5 @@
 const { empty } = require('.')
-const list = require('../sequence/list')
+const list = require('../sequence')
 
 {
     let m = empty.set('a')(1)

package/module-manager/index.js

@@ -3,7 +3,7 @@ const { pipe } = require('../function')
 const option = require('../option')
 const { head, last, splitLast, splitFirst } = array
 const iter = require('../sequence/iterable')
-const seq = require('../sequence')
+const seq = require('../sequence/operator')
 
 /**
  * @template T

package/package.json

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

package/sequence/asyncIterable/index.js

@@ -1,5 +1,5 @@
 const { pipe } = require('../../function')
-const seq = require('..')
+const seq = require('../operator')
 
 /**
  * @template T 

package/sequence/index.js

@@ -1,92 +1,344 @@
+const array = require('./array')
+const seqOp = require('./operator')
+const { pipe } = require('../function')
 const op = require('../function/operator')
+const { logicalNot, strictEqual } = require('../function/operator')
 
 /**
- * @template T0
- * @template T1
- * @typedef {import('./array').Tuple2<T0, T1>} Tuple2
+ * @template T
+ * @typedef {() => Result<T>} SequenceFn
  */
 
 /**
  * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ScanResult
+ * @typedef {readonly [Sequence<T>, Sequence<T>]} Concat
  */
 
 /**
+ * Use `next` function to get `first` and `tail` of the list.
+ * 
+ * Please note that the sequence also contains `Concat<T>. We need this as 
+ * a workaround because modern JavaScript implementations don't support 
+ * ES6 TCO (Tail Call Optimization). Without this wotkaround we may have 
+ * a stack overflow if a list contains a lot of concateneted lists. 
+ *
  * @template T
- * @template R
- * @typedef {(value: T) => ScanResult<T, R>} Scan
+ * @typedef { SequenceFn<T> | Concat<T>} Sequence
  */
 
 /**
  * @template T
- * @template R
- * @typedef {Tuple2<R, Scan<T, R>>} ExclusiveScan
+ * @typedef {FirstAndTail<T>|undefined} Result<T>
  */
 
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (prior: R) => Scan<T, R>} */
-const scan = operator => {
-    /** @typedef {typeof operator extends op.ReduceOperator<infer R, infer T> ? [R, T] : never} RT */
-    /** @typedef {RT[0]} R */
-    /** @typedef {RT[1]} T */
-    /** @type {(prior: R) => Scan<T, R>} */
-    const f = prior => value => {
-        const result = operator(prior)(value)
-        return [result, f(result)]
-    }
-    return f
-} 
-
-/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (first: R) => ExclusiveScan<T, R>} */
-const exclusiveScan = operator => first => [first, scan(operator)(first)]
-
-/** 
+/**
  * @template T
- * @typedef {Tuple2<number, T>} Entry
+ * @typedef {array.Tuple2<T, Sequence<T>>} FirstAndTail
  */
 
-/** @type {(index: number) => <T>(value: T) => ScanResult<T, Entry<T>>} */
-const createEntries = index => value => [[index, value], createEntries(index + 1)]
-
-const entries = createEntries(0)
+const empty = () => undefined
 
-/** @type {(separator: string) => ExclusiveScan<string, string>} */
-const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
+/** @type {<F, T>(a: readonly[F, Sequence<T>]) => (b: Sequence<T>) => readonly[F, Sequence<T>]} */
+const norm = ([a0, a1]) => b => [a0, [a1, b]]
 
-const sum = exclusiveScan(op.addition)(0)
+/** @type {<T>(input: Sequence<T>) => Result<T>} */
+const next = input => {
+    let i = input
+    while (true) {
+        if (typeof i === 'function') { return i() }
+        const [a, b] = i
+        if (typeof a === 'function') { 
+            const result = a()
+            if (result !== undefined) { 
+                return norm(result)(b)
+            }
+            i = b
+        } else {
+            i = norm(a)(b)
+        }
+    }
+}
 
-/** @type {(a: number) => () => number} */
-const counter = a => () => a + 1
+/** @type {<T>(input: Sequence<T>) => T|undefined} */
+const first = input => {
+    const result = next(input)
+    if (result === undefined) { return undefined }
+    return result[0]
+}
 
-const length = exclusiveScan(counter)(0)
+/**
+ * @template T
+ * @template R
+ * @typedef {(list: Sequence<T>) => Sequence<R>} SequenceMap
+ */
 
 /**
  * @template T
  * @template R
- * @typedef {(value: T) => R} Func
+ * @typedef {(list: Sequence<T>) => R} SequenceReduce
  */
 
-/** @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 {<T>(...array: readonly T[]) => Sequence<T>} */
+const list = (...array) => {
+    /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
+    let i = array.length
+    /** @type {Sequence<T>} */
+    let tail = empty
+    while (true) {
+        if (i === 0) { return tail }
+        i = i - 1
+        /** @type {FirstAndTail<T>} */
+        const result = [array[i], tail]
+        tail = () => result
+    }
+}
+
+/** @type {<T>(array: array.Array<T>) => Sequence<T>} */
+const fromArray = a => {
+    /** @typedef {typeof a extends array.Array<infer T> ? T : never} T */
+    /** @type {(index: number) => Sequence<T>} */
+    const at = index => () => {
+        const result = array.at(index)(a)
+        if (result === undefined) { return undefined }
+        return [result[0], at(index + 1)]
+    }
+    return at(0)
+}
+
+/** @type {<T>(...array: readonly Sequence<T>[]) => Sequence<T>} */
+const concat = (...array) => {
+    let i = array.length
+    if (i == 0) { return empty }
+    i = i - 1
+    let tail = array[i]
+    while (true) {        
+        if (i === 0) { return tail }
+        i = i - 1
+        tail = [array[i], tail]
+    }
+}
+
+/** @type {(_: number) => Sequence<number>} */
+const generate = n => {
+    /** @type {(_: number) => Sequence<number>} */
+    const f = i => () => {
+        if (n <= i) { return undefined }
+        return [i, f(i + 1)]
+    }
+    return f(0)
+}
+
+/** @type {<T, R>(f: (value: T) => Sequence<R>) => SequenceMap<T, R>} */
+const flatMap = f => input => () => {
+    let i = input
+    while (true) { 
+        const result = next(i)
+        if (result === undefined) { return undefined }
+        const [first, tail] = result
+        const firstResult = next(f(first)) 
+        if (firstResult !== undefined) {
+            return norm(firstResult)(flatMap(f)(tail))
+        }
+        i = tail
+    }
+}
+
+/** @type {<T>(list: Sequence<Sequence<T>>) => Sequence<T>} */
+const flat = flatMap(i => i)
+
+/** @type {<T, R>(f: (value: T) => R) => SequenceMap<T, R>} */
+const map = f => flatMap(i => list(f(i)))
+
+/** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
+const filter = f => flatMap(i => f(i) ? list(i) : empty)
+
+/** @type {<T, R>(f: (value: T) => R|undefined) => (value: T) => Sequence<R>} */
+const filterMapFunc = f => i => {
+    const result = f(i)
+    if (result === undefined) { return empty }
+    return list(result)
+}
+
+/** @type {<T, R>(f: (value: T) => R|undefined) => SequenceMap<T, R>} */
+const filterMap = f => flatMap(filterMapFunc(f)) 
+
+/** @type {<T, R>(s: seqOp.Scan<T, R>) => SequenceMap<T, R>} */
+const scan = s => input => () => {
+    const result = next(input)
+    if (result === undefined) {
+        return result
+    }
+    const [first, tail] = result
+    const [newFirst, newS] = s(first)
+    return [newFirst, scan(newS)(tail)]
+}
+
+/** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => SequenceMap<T, R>} */
+const exclusiveScan = ([first, s]) => input => () => [first, scan(s)(input)]
+
+/** @type {<T>(def: T) => (input: Sequence<T>) => T} */
+const last = def => input => {
+    let r = def
+    let i = input    
+    while (true) {
+        const result = next(i)
+        if (result === undefined) {
+            return r
+        }
+        r = result[0]
+        i = result[1]
+    }
+}
+
+/** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => (input: Sequence<T>) => R} */
+const reduce = ([first, s]) => input => last(first)(scan(s)(input))
+
+/** @type {<T, R>(ro: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
+const fold = ro => first => reduce(seqOp.exclusiveScan(ro)(first))
+
+const entries = scan(seqOp.entries)
+
+const sum = reduce(seqOp.sum)
+
+const length = reduce(seqOp.length)
+
+const join = pipe(seqOp.join)(reduce)
+
+/** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
+const takeWhile = f => input => () => {
+    const result = next(input)
+    if (result === undefined || !f(result[0])) { return undefined }
+    return result
+}
+
+/** @type {(n: number) => <T>(input: Sequence<T>) => Sequence<T>} */
+const drop = n => input => () => {
+    let iN = n
+    let iInput = input
+    while (true) {
+        const result = next(iInput)
+        if (iN <= 0 || result === undefined) { return result }
+        iN = iN - 1
+        iInput = result[1]
+    }
+}
+
+/** @type {(n: number) => <T>(input: Sequence<T>) => T|undefined} */
+const at = n => input => first(drop(n)(input))
+
+/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, T|undefined>} */
+const find = f => input => first(filter(f)(input))
+
+/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, boolean>} */
+const some = f => input => find(x => x)(map(f)(input)) !== undefined
 
-/** @type {<T, X>(flatMap: (f: Func<T, readonly[T]|[]>) => X) => (f: Func<T, boolean>) =>X} */
-const filter = flatMap => f => flatMap(x => f(x) ? [x] : [])
+/** @type {<T>(value: T) => SequenceReduce<T, boolean>} */
+const includes = value => some(strictEqual(value))
+
+/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, boolean>} */
+const every = f => input => !some(pipe(f)(logicalNot))(input)
+
+/** @type {<T>(list: Sequence<T>) => Iterable<T>} */
+const iterable = list => ({
+    *[Symbol.iterator]() {
+        let i = list
+        while (true) {
+            const result = next(i)
+            if (result === undefined) { return }
+            yield result[0]
+            i = result[1]
+        }
+    }
+})
+
+/** @type {<T>(list: Sequence<T>) => AsyncIterable<T>} */
+const asyncIterable = list => ({
+    async *[Symbol.asyncIterator]() {
+        let i = list
+        while (true) {
+            const result = next(i)
+            if (result === undefined) { return }
+            yield result[0]
+            i = result[1]
+        }
+    }
+})
+
+/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<array.Tuple2<A, B>>} */
+const zip = a => b => () => {
+    const resultA = next(a)
+    if (resultA === undefined) { return undefined }
+    const resultB = next(b)
+    if (resultB === undefined) { return undefined }
+    return [[resultA[0], resultB[0]], zip(resultA[1])(resultB[1])]
+}
+
+/** @type {<T>(list: Sequence<T>) => readonly T[]} */
+const toArray = input => Array.from(iterable(input))
 
 module.exports = {
     /** @readonly */
-    exclusiveScan,
+    next,
+    /** @readonly */
+    list,
+    /** @readonly */
+    empty,
+    /** @readonly */
+    at,
+    /** @readonly */
+    concat,
+    /** @readonly */
+    generate,
+    /** @readonly */
+    first,
+    /** @readonly */
+    fromArray,
+    /** @readonly */
+    toArray,
+    /** @readonly */
+    iterable,
+    /** @readonly */
+    asyncIterable,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    flat,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    filterMap,
     /** @readonly */
     scan,
     /** @readonly */
-    join,
+    exclusiveScan,
+    /** @readonly */
+    last,
+    /** @readonly */
+    fold,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    entries,
     /** @readonly */
     sum,
     /** @readonly */
+    join,
+    /** @readonly */
     length,
     /** @readonly */
-    entries,
+    drop,
     /** @readonly */
-    map,
+    find,
     /** @readonly */
-    filter,
-}
+    takeWhile,
+    /** @readonly */
+    some,
+    /** @readonly */
+    every,
+    /** @readonly */
+    includes,
+    /** @readonly */
+    zip,
+}

package/sequence/iterable/index.js

@@ -1,5 +1,5 @@
 const { pipe } = require('../../function')
-const seq = require('..')
+const seq = require('../operator')
 
 /** @type {<T>(a: Iterable<T>) => (b: Iterable<T>) => Iterable<T>} */
 const concat = a => b => ({

package/sequence/operator/index.js

@@ -0,0 +1,92 @@
+const op = require('../../function/operator')
+
+/**
+ * @template T0
+ * @template T1
+ * @typedef {import('../array').Tuple2<T0, T1>} Tuple2
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {Tuple2<R, Scan<T, R>>} ScanResult
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => ScanResult<T, R>} Scan
+ */
+
+/**
+ * @template T
+ * @template R
+ * @typedef {Tuple2<R, Scan<T, R>>} ExclusiveScan
+ */
+
+/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (prior: R) => Scan<T, R>} */
+const scan = operator => {
+    /** @typedef {typeof operator extends op.ReduceOperator<infer R, infer T> ? [R, T] : never} RT */
+    /** @typedef {RT[0]} R */
+    /** @typedef {RT[1]} T */
+    /** @type {(prior: R) => Scan<T, R>} */
+    const f = prior => value => {
+        const result = operator(prior)(value)
+        return [result, f(result)]
+    }
+    return f
+} 
+
+/** @type {<R, T>(operator: op.ReduceOperator<R, T>) => (first: R) => ExclusiveScan<T, R>} */
+const exclusiveScan = operator => first => [first, scan(operator)(first)]
+
+/** 
+ * @template T
+ * @typedef {Tuple2<number, T>} Entry
+ */
+
+/** @type {(index: number) => <T>(value: T) => ScanResult<T, Entry<T>>} */
+const createEntries = index => value => [[index, value], createEntries(index + 1)]
+
+const entries = createEntries(0)
+
+/** @type {(separator: string) => ExclusiveScan<string, string>} */
+const join = separator => ['', value => [value, scan(op.join(separator))(value)]]
+
+const sum = exclusiveScan(op.addition)(0)
+
+/** @type {(a: number) => () => number} */
+const counter = a => () => a + 1
+
+const length = exclusiveScan(counter)(0)
+
+/**
+ * @template T
+ * @template R
+ * @typedef {(value: T) => R} Func
+ */
+
+/** @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 {<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 */
+    exclusiveScan,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    join,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    length,
+    /** @readonly */
+    entries,
+    /** @readonly */
+    map,
+    /** @readonly */
+    filter,
+}

package/sequence/test.js

@@ -0,0 +1,62 @@
+const seq = require('.')
+const { sum } = require('./operator')
+const op = require('./operator')
+
+/** @type {<T>(input: seq.Sequence<T>) => void} */
+const print = input => {
+    let i = input
+    while (true) {
+        const result = seq.next(i)
+        if (result === undefined) { return }
+        console.log(result[0])
+        i = result[1]
+    }
+}
+
+{
+    const big = seq.fromArray([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60])
+    const list0 = seq.fromArray([0, 1, 2, 3])
+    const list1 = seq.flatMap(x => seq.fromArray([x, x * 2, x * 3]))(list0)
+    const list2 = seq.concat(list0, list0)
+    const list3 = seq.exclusiveScan(sum)(list0)
+    const r = seq.find(x => x === 42)(big)
+    if (seq.every(x => x > 0)(big) !== true) { throw 'x'}
+    if (seq.every(x => x < 20)(big) !== false) { throw 'x' }
+    if (seq.some(x => x > 100)(big) !== false) { throw 'x' }
+    if (seq.some(x => x > 50)(big) !== true) { throw 'x' }
+    if (seq.first(seq.drop(16)(big)) !== 42) { throw 'drop'}
+    {
+        const a = seq.toArray(seq.generate(1_000_000))
+        let x = seq.concat(seq.fromArray(a), big)
+        const r = seq.next(x)
+        // print(x)
+    }
+    {
+        const a = seq.map(seq.generate)(seq.generate(100_000))
+        const array = seq.toArray(a)
+        const x = seq.concat(...array)
+        const r = seq.next(x)
+        // print(x)
+    }
+    {
+        let x = big
+        for (let i = 0; i < 1_000_000; ++i) {
+            x = seq.concat(seq.empty, x)
+        }
+        const r = seq.next(x)
+        // print(x)
+    } 
+    {
+        let x = big
+        for (let i = 0; i < 1_000_000; ++i) {
+            x = seq.concat(x, seq.list(i))
+        }
+        const r = seq.next(x)
+        // print(x)
+    }
+}
+
+{
+    const x = seq.join(':')(seq.fromArray(["1", "2", "3", "4", "5", "6"]))
+    if (x !== "1:2:3:4:5:6") { throw x }
+}

package/test.js

@@ -1,10 +1,11 @@
 const i = require('./')
 
-require('./sequence/list/test')
+require('./sequence/test')
 require('./btree/test')
 require('./sequence/iterable/test')
 require('./sequence/asyncIterable/test')
 require('./module-manager/test')
+require('./json/test')
 
 /** @type {() => never} */
 const assert = () => { throw 'assert' }

package/sequence/list/index.js

@@ -1,305 +0,0 @@
-const array = require('../array')
-const base = require('..')
-const { pipe } = require('../../function')
-const { logicalNot, strictEqual } = require('../../function/operator')
-
-/**
- * @template T
- * @typedef {() => Result<T>} ListFunc
- */
-
-/**
- * @template T
- * @typedef {readonly [List<T>, List<T>]} Concat
- */
-
-/**
- * Use `next` function to get `first` and `tail` of the list.
- * 
- * Please note that the list also contains `Concat<T>. We need this as 
- * a workaround because modern JavaScript implementations don't support 
- * ES6 TCO (Tail Call Optimization). Without this wotkaround we may have 
- * a stack overflow if a list contains a lot of concateneted lists. 
- *
- * @template T
- * @typedef { ListFunc<T> | Concat<T>} List
- */
-
-/**
- * @template T
- * @typedef {FirstAndTail<T>|undefined} Result<T>
- */
-
-/**
- * @template T
- * @typedef {array.Tuple2<T, List<T>>} FirstAndTail
- */
-
-const empty = () => undefined
-
-/** @type {<F, T>(a: readonly[F, List<T>]) => (b: List<T>) => readonly[F, List<T>]} */
-const norm = ([a0, a1]) => b => [a0, [a1, b]]
-
-/** @type {<T>(list: List<T>) => Result<T>} */
-const next = list => {
-    let i = list
-    while (true) {
-        if (typeof i === 'function') { return i() }
-        const [a, b] = i
-        if (typeof a === 'function') { 
-            const result = a()
-            if (result !== undefined) { 
-                return norm(result)(b)
-            }
-            i = b
-        } else {
-            i = norm(a)(b)
-        }
-    }
-}
-
-/** @type {<T>(list: List<T>) => T|undefined} */
-const first = list => {
-    const result = next(list)
-    if (result === undefined) { return undefined }
-    return result[0]
-}
-
-/**
- * @template T
- * @template R
- * @typedef {(list: List<T>) => List<R>} ListMap
- */
-
-/**
- * @template T
- * @template R
- * @typedef {(list: List<T>) => R} ListReduce
- */
-
-/** @type {<T>(first: T) => List<T>} */
-const one = first => () => [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 => () => {
-        const result = array.at(index)(a)
-        if (result === undefined) { return undefined }
-        return [result[0], at(index + 1)]
-    }
-    return at(0)
-}
-
-/** @type {<T>(list0: List<T>) => ListMap<T, T>} */
-const concat = a => b => [a, b]
-
-/** @type {<T, R>(f: (value: T) => List<R>) => ListMap<T, R>} */
-const flatMap = f => input => () => {
-    let i = input
-    while (true) { 
-        const result = next(i)
-        if (result === undefined) { return undefined }
-        const [first, tail] = result
-        const firstResult = next(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>(f: (value: T) => R|undefined) => (value: T) => List<R>} */
-const filterMapFunc = f => i => {
-    const result = f(i)
-    if (result === undefined) { return empty }
-    return one(result)
-}
-
-/** @type {<T, R>(f: (value: T) => R|undefined) => ListMap<T, R>} */
-const filterMap = f => flatMap(filterMapFunc(f)) 
-
-/** @type {<T, R>(s: base.Scan<T, R>) => ListMap<T, R>} */
-const scan = s => input => () => {
-    const result = next(input)
-    if (result === undefined) {
-        return result
-    }
-    const [first, tail] = result
-    const [newFirst, newS] = s(first)
-    return [newFirst, scan(newS)(tail)]
-}
-
-/** @type {<T, R>(s: base.ExclusiveScan<T, R>) => ListMap<T, R>} */
-const exclusiveScan = ([first, s]) => input => () => [first, scan(s)(input)]
-
-/** @type {<T>(def: T) => (input: List<T>) => T} */
-const last = def => input => {
-    let r = def
-    let i = input    
-    while (true) {
-        const result = next(i)
-        if (result === undefined) {
-            return r
-        }
-        r = result[0]
-        i = result[1]
-    }
-}
-
-/** @type {<T, R>(s: base.ExclusiveScan<T, R>) => (input: List<T>) => R} */
-const reduce = ([first, s]) => input => last(first)(scan(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) => ListMap<T, T>} */
-const takeWhile = f => input => () => {
-    const result = next(input)
-    if (result === undefined || !f(result[0])) { return undefined }
-    return result
-}
-
-/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
-const drop = n => input => () => {
-    let iN = n
-    let iInput = input
-    while (true) {
-        const result = next(iInput)
-        if (iN <= 0 || result === undefined) { return result }
-        iN = iN - 1
-        iInput = result[1]
-    }
-}
-
-/** @type {(n: number) => <T>(input: List<T>) => T|undefined} */
-const at = n => input => first(drop(n)(input))
-
-/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, T|undefined>} */
-const find = f => input => first(filter(f)(input))
-
-/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, boolean>} */
-const some = f => input => find(x => x)(map(f)(input)) !== undefined
-
-/** @type {<T>(value: T) => ListReduce<T, boolean>} */
-const includes = value => some(strictEqual(value))
-
-/** @type {<T>(f: (value: T) => boolean) => ListReduce<T, boolean>} */
-const every = f => input => !some(pipe(f)(logicalNot))(input)
-
-/** @type {<T>(list: List<T>) => Iterable<T>} */
-const iterable = list => ({
-    *[Symbol.iterator]() {
-        let i = list
-        while (true) {
-            const result = next(i)
-            if (result === undefined) { return }
-            yield result[0]
-            i = result[1]
-        }
-    }
-})
-
-/** @type {<T>(list: List<T>) => AsyncIterable<T>} */
-const asyncIterable = list => ({
-    async *[Symbol.asyncIterator]() {
-        let i = list
-        while (true) {
-            const result = next(i)
-            if (result === undefined) { return }
-            yield result[0]
-            i = result[1]
-        }
-    }
-})
-
-/** @type {<A>(a: List<A>) => <B>(b: List<B>) => List<array.Tuple2<A, B>>} */
-const zip = a => b => () => {
-    const resultA = next(a)
-    if (resultA === undefined) { return undefined }
-    const resultB = next(b)
-    if (resultB === undefined) { return undefined }
-    return [[resultA[0], resultB[0]], zip(resultA[1])(resultB[1])]
-}
-
-/** @type {<T>(list: List<T>) => readonly T[]} */
-const toArray = input => Array.from(iterable(input))
-
-module.exports = {
-    /** @readonly */
-    next,
-    /** @readonly */
-    one,
-    /** @readonly */
-    empty,
-    /** @readonly */
-    at,
-    /** @readonly */
-    concat,
-    /** @readonly */
-    first,
-    /** @readonly */
-    fromArray,
-    /** @readonly */
-    toArray,
-    /** @readonly */
-    iterable,
-    /** @readonly */
-    asyncIterable,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    filterMap,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
-    /** @readonly */
-    last,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    join,
-    /** @readonly */
-    length,
-    /** @readonly */
-    drop,
-    /** @readonly */
-    find,
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    some,
-    /** @readonly */
-    every,
-    /** @readonly */
-    includes,
-    /** @readonly */
-    zip,
-}

package/sequence/list/test.js

@@ -1,43 +0,0 @@
-const list = require('.')
-const { sum } = require('..')
-
-/** @type {<T>(l: list.List<T>) => void} */
-const print = a => {
-    let i = a
-    while (true) {
-        const result = list.next(i)
-        if (result === undefined) { return }
-        // console.log(result[0])
-        i = result[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.exclusiveScan(sum)(list0)
-    const r = list.find(x => x === 42)(big)
-    if (list.every(x => x > 0)(big) !== true) { throw 'x'}
-    if (list.every(x => x < 20)(big) !== false) { throw 'x' }
-    if (list.some(x => x > 100)(big) !== false) { throw 'x' }
-    if (list.some(x => x > 50)(big) !== true) { throw 'x' }
-    if (list.first(list.drop(16)(big)) !== 42) { throw 'drop'}
-    {
-        let x = big
-        for (let i = 0; i < 1_000_000; ++i) {
-            x = list.concat(list.empty)(x)
-        }
-        const r = list.next(x)
-        // print(x)
-    } 
-    {
-        let x = big
-        for (let i = 0; i < 1_000_000; ++i) {
-            x = list.concat(x)(list.one(i))
-        }
-        const r = list.next(x)
-        // print(x)
-    }
-}