functionalscript 0.0.217 → 0.0.222

package/README.md

@@ -13,6 +13,12 @@ Create a new FunctionalScript repository on GitHub [here](https://github.com/fun
 One of the main challenges is how to make a pure functional language when ES6 TCO is not supported by Chrome and Firefox.
 A workaround for this problem is to use `let` for renaming objects.
 
+## Install FunctionalScript As A Library
+
+```
+npm install -S github:functionalscript/functionalscript
+```
+
 ## JSON
 
 ```js

package/btree/index.js

@@ -309,20 +309,20 @@ const replaceVisitor = {
 const values = node => () => {
     const f = () => {
         switch (node.length) {
-            case 1: case 2: { return seq.list(...node) }
+            case 1: case 2: { return node }
             case 3: { 
                 return seq.concat(
                     values(node[0]), 
-                    seq.list(node[1]), 
+                    [node[1]], 
                     values(node[2])
                 )
             }
             default: {
                 return seq.concat(
                     values(node[0]),
-                    seq.list(node[1]),
+                    [node[1]],
                     values(node[2]),
-                    seq.list(node[3]),
+                    [node[3]],
                     values(node[4])
                 )
             }

package/btree/test.js

@@ -25,7 +25,7 @@ const test = () => {
         /** @type {import('../sequence').Result<string>} */
         let _item = list.next(values(_map))
         while (_item !== undefined) {
-            _item = list.next(_item[1])
+            _item = list.next(_item.tail)
         }
     }
 }

package/function/index.js

@@ -4,8 +4,12 @@
  * @typedef {(_: I) => O} Func 
  */
 
-/** @type {<X, O>(f: Func<X, O>) => <I>(g: Func<I, X>) => Func<I, O>} */
-const compose = f => g => x => f(g(x))
+/** 
+ * Postfix Compose function.
+ *
+ * @type {<I, X>(g: Func<I, X>) => <O>(f: Func<X, O>) => Func<I, O>} 
+ */
+const compose = g => f => x => f(g(x))
 
 /** @type {<T>(value: T) => T} */
 const identity = value => value

package/json/index.js

@@ -14,53 +14,50 @@ const { compose } = require('../function')
 
 /** @typedef {Object|boolean|string|number|null|Array} Json */
 
-/** @type {(value: Json) => (path: readonly string[]) => (src: Json|undefined) => Json} */
+/** @type {(value: Json) => (path: seq.Sequence<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)(object.at(name)(srcObject)) }
-    }
-    return compose(f)(array.sequence)
+        const { first, tail } = result
+        return { ...srcObject, [first]: f(tail)(object.at(first)(srcObject)) }
+    }    
+    return f
 }
 
 /** @type {(_: string) => seq.Sequence<string>} */
-const stringSerialize = input => seq.list(JSON.stringify(input))
+const stringSerialize = input => [JSON.stringify(input)]
 
 /** @type {(_: number) => seq.Sequence<string>} */
-const numberSerialize = input => seq.list(JSON.stringify(input))
+const numberSerialize = input => [JSON.stringify(input)]
 
-const nullSerialize = seq.list('null')
+const nullSerialize = ['null']
 
-const trueSerialize = seq.list('true')
+const trueSerialize = ['true']
 
-const falseSerialize = seq.list('false')
+const falseSerialize = ['false']
 
 /** @type {(_: boolean) => seq.Sequence<string>} */
 const boolSerialize = value => value ? trueSerialize : falseSerialize
 
-const colon = seq.list(':')
-const comma = seq.list(',')
+const colon = [':']
+const comma = [',']
 
 /** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
 const commaValue = a => [seq.concat(comma, a), commaValue]
 
-/** @type {op.Scan<seq.Sequence<string>, seq.Sequence<string>>} */
-const joinScan = value => [value, commaValue]
+/** @type {seq.FoldOperator<seq.Sequence<string>>} */
+const joinOp = a => b => seq.concat(a, comma, b)
 
-/** @type {seq.SequenceMap<seq.Sequence<string>, string>} */
-const join = input => {
-    const _0 = seq.scan(joinScan)(input)
-    return seq.flat(_0)
-}
+/** @type {(input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+const join = seq.fold(joinOp)([])
 
 /** @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)
+    const seqOpen = [open]
+    const seqClose = [close]
     return input => seq.concat(seqOpen, join(input), seqClose)
 }
 
@@ -83,15 +80,15 @@ const serialize = sort => {
         f(v))
     /** @type {(object: Object) => seq.Sequence<string>} */
     const objectSerialize = input => {
-        const entries = object.entries(input)
+        const entries = Object.entries(input)
         const sortedEntries = sort(entries)
+        const _ = seq.toArray(sortedEntries)
         const serializedEntries = seq.map(propertySerialize)(sortedEntries)
         return objectList(serializedEntries)
     }
     /** @type {(input: Array) => seq.Sequence<string>} */
     const arraySerialize = input => {
-        const sequence = array.sequence(input)
-        const serializedEntries = seq.map(f)(sequence)
+        const serializedEntries = seq.map(f)(input)
         return arrayList(serializedEntries)
     }
     /** @type {(value: Json) => seq.Sequence < string >} */
@@ -118,7 +115,10 @@ const serialize = sort => {
  *  
  * @type {(mapEntries: MapEntries) => (value: Json) => string}
  */
-const stringify = sort => value => seq.join('')(serialize(sort)(value))
+const stringify = sort => value => {
+    const _s = serialize(sort)(value)
+    return seq.join('')(_s)
+}
 
 /** @type {(value: string) => Json} */
 const parse = value => JSON.parse(value)

package/json/test.js

@@ -5,7 +5,8 @@ const { identity } = require('../function')
 if (json.addProperty("Hello")([])({}) !== "Hello") { throw 'error' }
 
 {
-    const x = json.stringify(sort)(json.addProperty("Hello")(['a'])({}))
+    const r = json.addProperty("Hello")(['a'])({})
+    const x = json.stringify(sort)(r)
     if (x !== '{"a":"Hello"}') { throw x }
 }
 

package/map/index.js

@@ -56,14 +56,14 @@ const create = root => ({
  * @type {{
  *  readonly get: (name: string) => undefined
  *  readonly set: (name: string) => <T>(value: T) => Map<T>
- *  readonly entries: () => undefined
+ *  readonly entries: []
  *  readonly root: undefined
  * }} 
  */
 const empty = {
     get: () => undefined,
     set: name => value => create([[name, value]]),
-    entries: seq.empty,
+    entries: [],
     root: undefined
 }
 
@@ -73,7 +73,9 @@ const setOperator = map => ([k, v]) => map.set(k)(v)
 /** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
 const fromEntries = entries => {
     /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */
-    return seq.fold(setOperator)(/** @type {Map<T>} */(empty))(entries)
+    /** @type {Map<T>} */
+    const init = empty
+    return seq.reduce(setOperator)(init)(entries)
 }
 
 module.exports = {

package/module-manager/index.js

@@ -82,15 +82,11 @@ const internal = pack => {
 const externalOrInternal = p => 
     p === undefined ? () => undefined : (typeof p === 'function' ? external(p) : internal(p))
 
-/** @type {(_: Dependencies) => (_: Path) => Module|undefined} */
+/** @type {(_: Dependencies) => (path: Path) => Module|undefined} */
 const external = packages => { 
     /** @type {(_: readonly [string, Path]) => Module|undefined} */
     const defined = ([first, tail]) => externalOrInternal(packages(first))(tail)
-    /** @type {(_: Path) => readonly [string, Path]|undefined} */
-    const sf = splitFirst
-    return compose
-        (option.map(defined))
-        (sf)        
+    return path => option.map(defined)(splitFirst(path))
 }
 
 /** @type {(_: Location) => (_: string) => Module|undefined} */

package/object/index.js

@@ -14,9 +14,6 @@ const map = require('../map')
  * @typedef {readonly[string, T]} Entry
  */
 
-/** @type {<T>(object: Map<T>) => seq.Sequence<Entry<T>>} */
-const entries = object => array.sequence(Object.entries(object))
-
 /** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
 const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
 
@@ -24,8 +21,6 @@ const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.valu
 const sort = entries => map.fromEntries(entries).entries
 
 module.exports = {
-    /** @readonly */
-    entries,
     /** @readonly */
     at,
     /** @readonly */

package/package.json

@@ -1,6 +1,6 @@
 {
    "name": "functionalscript",
-   "version": "0.0.217",
+   "version": "0.0.222",
    "description": "FunctionalScript is a functional subset of JavaScript",
    "main": "index.js",
    "scripts": {
@@ -19,7 +19,7 @@
    },
    "homepage": "https://github.com/functionalscript/functionalscript#readme",
    "devDependencies": {
-      "@types/node": "^16.11.9",
+      "@types/node": "^16.11.11",
       "typescript": "^4.5.2"
    }
 }

package/sequence/README.md

@@ -2,11 +2,26 @@
 
 Sequence types:
 
+- Sequence
 - Array
-- List
 - Iterable
 - AsyncIterable
 
+# Sequence Types
+
+```ts
+type Sequence<T> = 
+    readonly T[] |
+    Thunk<T> |
+
+type Thunk<T> = () => Node<T>
+
+type Node<T> =
+    undefined |
+    { readonly first: T, readonly tail: Sequence<T> } |
+    readonly[Sequence<T>, Sequence<T>]
+```
+
 ## Functions
 
 See https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array

package/sequence/array/index.js

@@ -95,21 +95,6 @@ const splitLast = a => {
 /** @type {(index: number) => <T>(a: Array<T>) => readonly[T]|undefined} */
 const at = index => a => index < a.length ? [a[index]] : undefined
 
-/** @type {<T>(array: Array<T>) => seq.Sequence<T>} */
-const sequence = a => {
-    /** @typedef {typeof a extends Array<infer T> ? T : never} T */
-    /** @type {(index: number) => seq.Sequence<T>} */
-    const seq = index => () => {
-        const result = at(index)(a)
-        if (result === undefined) { return undefined }
-        return [result[0], seq(index + 1)]
-    }
-    return seq(0)
-}
-
-/** @type {<T>(list: seq.Sequence<T>) => readonly T[]} */
-const fromSequence = input => Array.from(seq.iterable(input))
-
 module.exports = {
     /** @readonly */
     at,
@@ -125,8 +110,4 @@ module.exports = {
     splitFirst,
     /** @readonly */
     splitLast,
-    /** @readonly */
-    sequence,
-    /** @readonly */
-    fromSequence,
 }

package/sequence/asyncIterable/index.js

@@ -69,7 +69,7 @@ const reduce = ([first, s]) => async c => {
 
 const sum = reduce(seq.sum)
 
-const join = compose(reduce)(seq.join)
+const join = compose(seq.join)(reduce)
 
 const length = reduce(seq.length)
 

package/sequence/index.js

@@ -1,348 +1,327 @@
-const seqOp = require('./operator')
 const { compose } = require('../function')
+const { logicalNot, strictEqual, addition } = require('../function/operator')
 const op = require('../function/operator')
-const { logicalNot, strictEqual } = require('../function/operator')
 
 /**
  * @template T
- * @typedef {() => Result<T>} SequenceFn
+ * @typedef { readonly T[] | Thunk<T> } Sequence<T>
  */
 
 /**
  * @template T
- * @typedef {readonly [Sequence<T>, Sequence<T>]} Concat
+ * @typedef { () => Node<T> } Thunk
  */
 
 /**
- * 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 workaround, we may have 
- * a stack overflow if a list contains a lot of concateneted lists. 
- *
  * @template T
- * @typedef { SequenceFn<T> | Concat<T>} Sequence
+ * @typedef { Result<T> | Concat<T> } Node<T>
  */
 
 /**
  * @template T
- * @typedef {FirstAndTail<T>|undefined} Result<T>
+ * @typedef { readonly[Sequence<T>, Sequence<T>] } Concat<T>
  */
 
 /**
  * @template T
- * @typedef {readonly[T, Sequence<T>]} FirstAndTail
+ * @typedef { undefined | ResultOne<T> } Result
  */
 
-const empty = () => undefined
-
-/** @type {<T>(first: T) => (tail: Sequence<T>) => Sequence<T>} */
-const sequence = first => tail => () => [first, tail]
-
-/** @type {<F, T>(a: readonly[F, Sequence<T>]) => (b: Sequence<T>) => readonly[F, Sequence<T>]} */
-const norm = ([a0, a1]) => b => [a0, [a1, b]]
-
-/** @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 {<T>(input: Sequence<T>) => T|undefined} */
-const first = input => {
-    const result = next(input)
-    if (result === undefined) { return undefined }
-    return result[0]
-}
-
 /**
  * @template T
- * @template R
- * @typedef {(list: Sequence<T>) => Sequence<R>} SequenceMap
+ * @typedef {{ readonly first: T, readonly tail: Sequence<T> }} ResultOne
  */
 
-/**
- * @template T
- * @template R
- * @typedef {(list: Sequence<T>) => R} SequenceReduce
- */
+const empty = () => undefined
 
-/**
- * Note: the operation is not lazy. It traverses the given array and creates a linked list.
- *  
- * @type {<T>(...array: readonly T[]) => Sequence<T>} 
- */
-const list = (...array) => {
+/** @type {<T>(array: readonly T[]) => Result<T>} */
+const fromArray = array => {
     /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
-    let i = array.length
-    /** @type {Sequence<T>} */
-    let iResult = empty
-    while (i !== 0) {
-        i = i - 1
-        iResult = sequence(array[i])(iResult)
+    /** @type {(index: number) => Result<T>} */
+    const at = index => {
+        if (array.length <= index) { return undefined }
+        return { first: array[index], tail: () => at(index + 1) }
     }
-    return iResult
+    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 result = array[i]
-    while (i !== 0) {
-        i = i - 1
-        result = [array[i], result]
+/** @type {<T>(sequence: Sequence<T>) => Node<T>} */
+const node = sequence => sequence instanceof Array ? fromArray(sequence) : sequence()
+
+/** @type {<T>(concat: Concat<T>) => Sequence<T>} */
+const concatNext = ([a, b]) => {
+    const result = node(a)
+    if (result === undefined) {
+        return b
+    } else if (result instanceof Array) {
+        const [aa, ab] = result
+        return () => [aa, () => [ab, b]]
+    } else {
+        const { first, tail } = result
+        return () => ({ first, tail: () => [tail, b] })
     }
-    return result
 }
 
-/** @type {(_: number) => Sequence<number>} */
-const generate = n => {
-    /** @type {(_: number) => Sequence<number>} */
-    const f = i => () => {
-        if (n <= i) { return undefined }
-        return [i, f(i + 1)]
+/** @type {<T>(sequence: Sequence<T>) => Result<T>} */
+const next = sequence => {
+    let i = sequence
+    while (true) {
+        const n = node(i)
+        if (!(n instanceof Array)) { return n }
+        i = concatNext(n)
     }
-    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))
+/** @type {<T>(sequence: Sequence<T>) => Iterable<T>} */
+const iterable = sequence => ({
+    *[Symbol.iterator]() {
+        let i = sequence
+        while (true) {
+            if (i instanceof Array) { return yield *i }
+            const n = next(i)
+            if (n === undefined) { return }
+            const { first, tail } = n
+            yield first
+            i = tail
         }
-        i = tail
     }
+})
+
+/** @type {<T>(sequence: Sequence<T>) => readonly T[]} */
+const toArray = sequence => {
+    if (sequence instanceof Array) { return sequence }
+    return Array.from(iterable(sequence))
+}
+
+/** @type {<I, O>(f: (result: ResultOne<I>) => Node<O>) => (input: Sequence<I>) => Thunk<O>} */
+const nextMap = f => input => () => {
+    const n = next(input)
+    if (n === undefined) { return undefined }
+    return f(n)
 }
 
-/** @type {<T>(list: Sequence<Sequence<T>>) => Sequence<T>} */
-const flat = flatMap(i => i)
+/** @type {<T>(result: ResultOne<Sequence<T>>) => Node<T>} */
+const flatFn = ({first, tail}) => [first, flat(tail)]
 
-/** @type {<T, R>(f: (value: T) => R) => SequenceMap<T, R>} */
-const map = f => flatMap(i => list(f(i)))
+/** @type {<T>(sequence: Sequence<Sequence<T>>) => Thunk<T>} */
+const flat = nextMap(flatFn)
 
-/** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
-const filter = f => flatMap(i => f(i) ? list(i) : empty)
+/** @type {<T>(...array: readonly Sequence<T>[]) => Thunk<T>} */
+const concat = (...array) => flat(array)
 
-/** @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 {<I, O>(f: (value: I) => O) => (result: ResultOne<I>) => Node<O>} */
+const mapFn = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
+
+/** @type {<I, O>(f: (value: I) => O) => (input: Sequence<I>) => Thunk<O>} */
+const map = f => nextMap(mapFn(f))
+
+/** @type {<I, O>(f: (value: I) => Sequence<O>) => (input: Sequence<I>) => Thunk<O>} */
+const flatMap = f => compose(map(f))(flat)
+
+/** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
+const filterFn = f => ({ first, tail }) => {
+    const fTail = filter(f)(tail)
+    return f(first) ? { first, tail: fTail } : fTail()
+}
+
+/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
+const filter = f => nextMap(filterFn(f))
+
+/** @type {<I, O>(f: (value: I) => O|undefined) => (result: ResultOne<I>) => Node<O>} */
+const filterMapFn = f => ({first, tail}) => {
+    const fFirst = f(first)
+    const fTail = filterMap(f)(tail)
+    return fFirst === undefined ? fTail() : { first: fFirst, tail: fTail }
 }
 
-/** @type {<T, R>(f: (value: T) => R|undefined) => SequenceMap<T, R>} */
-const filterMap = f => flatMap(filterMapFunc(f)) 
+/** @type {<I, O>(f: (value: I) => O|undefined) => (input: Sequence<I>) => Thunk<O>} */
+const filterMap = f => nextMap(filterMapFn(f))
 
-/** @type {<T, R>(s: seqOp.Scan<T, R>) => SequenceMap<T, R>} */
-const scan = s => input => () => {
+/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
+const takeWhile = f => input => () => {
     const result = next(input)
-    if (result === undefined) {
-        return result
+    if (result === undefined) { return undefined }
+    const { first, tail } = result
+    if (!f(first)) { return undefined }
+    return { first, tail: takeWhile(f)(result.tail) }
+}
+
+/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
+const dropWhile = f => input => () => {
+    let i = input
+    while (true) {
+        const result = next(i)
+        if (result === undefined) { return undefined }
+        const { first, tail } = result
+        if (!f(first)) return result
+        i = tail
     }
-    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 {<D>(def: D) => <T>(input: Sequence<T>) => D|T} */
+const first = def => input => {
+    const result = next(input)
+    if (result === undefined) { return def }
+    return result.first
+}
 
-/** @type {<T>(def: T) => (input: Sequence<T>) => T} */
+/** @type {<D>(def: D) => <T>(input: Sequence<T>) => D|T} */
 const last = def => input => {
+    /** @typedef {typeof input extends Sequence<infer T> ? T : never} T */
+    /** @type {(typeof def)|T} */
     let r = def
-    let i = input    
+    let i = input
     while (true) {
         const result = next(i)
         if (result === undefined) {
             return r
         }
-        r = result[0]
-        i = result[1]
+        r = result.first
+        i = result.tail
     }
 }
 
-/** @type {<T, R>(s: seqOp.ExclusiveScan<T, R>) => (input: Sequence<T>) => R} */
-const reduce = ([first, s]) => input => last(first)(scan(s)(input))
+/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => D|T} */
+const find = def => f => input => first(def)(filter(f)(input))
 
-/** @type {<T, R>(operator: op.ReduceOperator<R, T>) => (first: R) => (input: Sequence<T>) => R} */
-const fold = operator => first => reduce(seqOp.exclusiveScan(operator)(first))
+/** @type {<T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
+const some = f => input => find(false)(x => x)(map(f)(input))
 
-const entries = scan(seqOp.entries)
+/** @type {<T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
+const every = f => input => !some(compose(f)(logicalNot))(input)
 
-const sum = reduce(seqOp.sum)
+/** @type {<T>(value: T) => (sequence: Sequence<T>) => boolean} */
+const includes = value => some(strictEqual(value))
 
-const length = reduce(seqOp.length)
+/** @type {(count: number) => Thunk<number>} */
+const countdown = count => () => {
+    if (count <= 0) { return undefined }
+    const first = count - 1
+    return { first, tail: countdown(first) }
+}
 
-/** @type {(separator: string) => SequenceReduce<string, string>} */
-const join = separator => reduce(seqOp.join(separator))
+/**
+ * @template T,A
+ * @typedef {(value: T) => ScanState<T, A>} ScanFunc
+ */
 
-/** @type {<T>(f: (value: T) => boolean) => SequenceMap<T, T>} */
-const takeWhile = f => input => () => {
+/**
+ * @template T,A
+ * @typedef {readonly[A, ScanFunc<T, A>]} ScanState
+ */
+
+/** @type {<T,A>(operator: ScanFunc<T, A>) => (input: Sequence<T>) => Thunk<A>} */
+const scan = operator => input => () => {
     const result = next(input)
-    if (result === undefined || !f(result[0])) { return undefined }
-    return result
+    if (result === undefined) { return undefined }
+    const { first, tail } = result
+    const r = operator(first)
+    return { first: r[0], tail: scan(r[1])(tail) }
 }
 
-/** @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 {<T,A>(operator: ScanFunc<T, A>) => <D>(def: D)=> (input: Sequence<T>) => D|A} */
+const scanReduce = operator => def => input => last(def)(scan(operator)(input))
+
+/**
+ * @template T,A 
+ * @typedef {(prior: A) => (value: T) => A} ReduceOperator
+ */
+
+/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanState<T, A>} */
+const scanState = operator => init => [init, scanFunc(operator)(init)]
+
+/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanFunc<T, A>} */
+const scanFunc = operator => init => value => {
+    const result = operator(init)(value)
+    return scanState(operator)(result)
 }
 
-/** @type {(n: number) => <T>(input: Sequence<T>) => T|undefined} */
-const at = n => input => first(drop(n)(input))
+/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => (input: Sequence<T>) => A} */
+const reduce = operator => init => scanReduce(scanFunc(operator)(init))(init)
 
-/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, T|undefined>} */
-const find = f => input => first(filter(f)(input))
+/** 
+ * @template T
+ * @typedef {ReduceOperator<T, T>} FoldOperator
+ */
 
-/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, boolean>} */
-const some = f => input => find(x => x)(map(f)(input)) !== undefined
+/** @type {<T>(operator: FoldOperator<T>) => <D>(def: D) => (input: Sequence<T>) => D|T} */
+const fold = operator => def => scanReduce(scanState(operator))(def)
 
-/** @type {<T>(value: T) => SequenceReduce<T, boolean>} */
-const includes = value => some(strictEqual(value))
+const sum = fold(addition)(0)
 
-/** @type {<T>(f: (value: T) => boolean) => SequenceReduce<T, boolean>} */
-const every = f => input => !some(compose(logicalNot)(f))(input)
+/** @type {(separator: string) => (input: Sequence<string>) => string} */
+const join = separator => fold(op.join(separator))('')
 
-/** @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 {(a: number) => () => number} */
+const counter = a => () => a + 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 {<T>(input: Sequence<T>) => number} */
+const length = reduce(counter)(0)
 
-/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Sequence<readonly[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])]
-}
+/**
+ * @template T
+ * @typedef {readonly[number, T]} Entry
+ */
 
-/** @type {<T>(s: Sequence<T>) => Sequence<T>} */
-const reverse = s => {
-    /** @type {typeof s} */
-    let iResult = empty
-    let iSource = s
-    while (true) {
-        const result = next(iSource)
-        if (result === undefined) { return iResult }
-        const [first, tail] = result
-        iResult = sequence(first)(iResult)
-        iSource = tail
-    }
-}
+/** @type {(index: number) => <T>(value: T) => ScanState<T, Entry<T>>} */
+const entryOp = index => value => [[index, value], entryOp(index + 1)]
+
+/** @type {<T>(input: Sequence<T>) => Thunk<Entry<T>>} */
+const entries = scan(entryOp(0))
 
 module.exports = {
     /** @readonly */
-    next,
+    empty,
     /** @readonly */
-    list,
+    iterable,
     /** @readonly */
-    empty,
+    next,
+    /** @readonly */
+    toArray,
     /** @readonly */
-    sequence,
+    flat,
     /** @readonly */
-    at,
+    last,
     /** @readonly */
     concat,
     /** @readonly */
-    generate,
-    /** @readonly */
     first,
     /** @readonly */
-    iterable,
-    /** @readonly */
-    asyncIterable,
+    map,
     /** @readonly */
     flatMap,
     /** @readonly */
-    flat,
-    /** @readonly */
-    map,
-    /** @readonly */
     filter,
     /** @readonly */
-    filterMap,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    exclusiveScan,
+    find,
     /** @readonly */
-    last,
+    some,
     /** @readonly */
-    fold,
+    every,
     /** @readonly */
-    reduce,
+    includes,    
     /** @readonly */
-    entries,
+    takeWhile,
     /** @readonly */
-    sum,
+    dropWhile,
     /** @readonly */
-    join,
+    scanFunc,
     /** @readonly */
-    length,
+    scanState,
     /** @readonly */
-    drop,
+    scan,
     /** @readonly */
-    find,
+    reduce,
     /** @readonly */
-    takeWhile,
+    fold,
     /** @readonly */
-    some,
+    sum,
     /** @readonly */
-    every,
+    join,
     /** @readonly */
-    includes,
+    entries,
     /** @readonly */
-    zip,
+    length,
     /** @readonly */
-    reverse,
-}
+    countdown,
+}

package/sequence/iterable/index.js

@@ -39,7 +39,7 @@ const sum = reduce(seq.sum)
 
 const length = reduce(seq.length)
 
-const join = compose(reduce)(seq.join)
+const join = compose(seq.join)(reduce)
 
 /** @type {<T, R>(f: (value: T) => Iterable<R>) => (c: Iterable<T>) => Iterable<R>} */
 const flatMap = f => c => ({

package/sequence/iterable/test.js

@@ -34,8 +34,8 @@ const { compose } = require('../../function')
     const file = _ => 'x'
     /** @type {(_: string) => string|undefined} */
     const x = p => compose
-        (i.find(x => x !== undefined))
-        (i.map(x => file(x())))        
+        (i.map(x => file(x())))
+        (i.find(x => x !== undefined))                
         ([() => p, () => `${p}.js`, () => `${p}/index.js`])
     if (x('index.js') !== 'x') { throw 'error' }
 }

package/sequence/operator/index.js

@@ -35,7 +35,7 @@ const scan = operator => {
         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)]

package/sequence/test.js

@@ -1,75 +1,142 @@
-const seq = require('.')
-const { empty, next, list, flatMap, concat, exclusiveScan, find, every, some, first, drop, map, generate } = require('.')
-const { sum } = require('./operator')
-const array = require('./array')
+const _ = require('.')
 const json = require('../json')
-const { identity } = require('../function')
-
-/** @type {<T>(input: seq.Sequence<T>) => void} */
-const print = input => {
-    let i = input
-    while (true) {
-        const result = next(i)
-        if (result === undefined) { return }
-        console.log(result[0])
-        i = result[1]
-    }
+const { sort } = require('../object')
+const { addition } = require('../function/operator')
+
+/** @type {(sequence: _.Sequence<json.Json>) => string} */
+const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
+
+{
+    const s = stringify([1, 2, 3])
+    if (s !== '[1,2,3]') { throw s }
+}
+
+{
+    const result = stringify(_.countdown(10))
+    if (result !== '[9,8,7,6,5,4,3,2,1,0]') { throw result }
+}
+
+{
+    const result = stringify(_.concat([1, 2, 3], [4, 5], [6], [], [7, 8, 9]))
+    if (result !== '[1,2,3,4,5,6,7,8,9]') { throw result }
+}
+
+{
+    const result = _.concat([1], [2])
+    const x = _.next(result)
+}
+
+{
+    const result = stringify(_.flatMap(x => [x, x * 2, x * 3])([0, 1, 2, 3]))
+    if (result !== '[0,0,0,1,2,3,2,4,6,3,6,9]') { throw result }
 }
 
 {
-    const big = list(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 42, 60)
-    const list0 = list(0, 1, 2, 3)
-    const list1 = flatMap(x => list(x, x * 2, x * 3))(list0)
-    const list2 = concat(list0, list0)
-    const list3 = exclusiveScan(sum)(list0)
-    const r = find(x => x === 42)(big)
-    if (every(x => x > 0)(big) !== true) { throw 'x' }
-    if (every(x => x < 20)(big) !== false) { throw 'x' }
-    if (some(x => x > 100)(big) !== false) { throw 'x' }
-    if (some(x => x > 50)(big) !== true) { throw 'x' }
-    if (first(drop(16)(big)) !== 42) { throw 'drop' }
+    const result = stringify(_.takeWhile(x => x < 6)([1, 2, 3, 4, 5, 6, 7, 8, 9]))
+    if (result !== '[1,2,3,4,5]') { throw result }
+}
+
+{
+    const result = _.find(undefined)(x => x % 2 === 0)([1, 2, 3, 4])
+    if (result !== 2) { throw result }
+}
+
+{
+    const result = stringify(_.takeWhile(x => x < 10)([1, 2, 3, 4, 5, 10, 11]))
+    if (result !== '[1,2,3,4,5]') { throw result }
+}
+
+{
+    const result = stringify(_.dropWhile(x => x < 10)([1, 2, 3, 4, 5, 10, 11]))
+    if (result !== '[10,11]') { throw result }
+}
+
+{
+    const op = _.scanState(addition)
+    const result = stringify(_.scan(op)([2, 3, 4, 5]))
+    if (result !== '[2,5,9,14]') { throw result }
+}
+
+{
+    const result = _.sum([2, 3, 4, 5])
+    if (result !== 14) { throw result }
+}
+
+{
+    const result = _.fold(addition)(undefined)([2, 3, 4, 5])
+    if (result !== 14) { throw result }
+}
+
+{
+    const result = _.fold(addition)(undefined)([])
+    if (result !== undefined) { throw result }
+}
+
+{
+    const result = _.join('/')([])
+    if (result !== '') { throw result }
+}
+
+{
+    const result = _.join('/')([''])
+    if (result !== '') { throw result }
+}
+
+{
+    const result = stringify(_.entries([]))
+    if (result !== '[]') { throw result }
+}
+
+{
+    const result = stringify(_.entries(['hello', 'world']))
+    if (result !== '[[0,"hello"],[1,"world"]]') { throw result }
+}
+
+// stress tests
+
+const stress = () => {
     {
-        const a = map(generate)(generate(100_000))
-        const ar = array.fromSequence(a)
-        // This operation uses a lot of stack because `...` 
-        // puts array items on a stack.
-        // Use `array.sequence` instead
-        const x = concat(...ar)
-        const r = next(x)
-        // print(x)
+        // 200_000_000 is too much
+        const n = 100_000_000
+        const result = _.toArray(_.countdown(n))
+        if (result.length !== n) { throw result.length }
+        const first = _.first(undefined)(result)
+        if (first !== n - 1) { throw first }
     }
+
     {
-        const a = array.fromSequence(generate(1_000_000))
-        let x = concat(array.sequence(a), big)
-        const r = next(x)
-        // print(x)
+        /** @type {_.Sequence<number>} */
+        let sequence = []
+        // 2_000_000 is too much
+        for (let i = 0; i < 1_000_000; ++i) {
+            sequence = _.concat(sequence, [i])
+        }
+        const r = _.toArray(sequence)
     }
+
     {
-        let x = big
-        for (let i = 0; i < 1_000_000; ++i) {
-            x = concat(empty, x)
+        /** @type {_.Sequence<number>} */
+        let sequence = []
+        // 5_000_000 is too much
+        for (let i = 0; i < 2_000_000; ++i) {
+            sequence = _.concat(sequence, [i])
         }
-        const r = next(x)
-        // print(x)
+        const a = _.next(sequence)
     }
+
     {
-        let x = big
-        for (let i = 0; i < 1_000_000; ++i) {
-            x = concat(x, list(i))
+        /** @type {_.Sequence<number>} */
+        let sequence = []
+        // 10_000_000 is too much
+        for (let i = 0; i < 5_000_000; ++i) {
+            sequence = _.concat([i], sequence)
         }
-        const r = next(x)
-        // print(x)
+        const a = _.next(sequence)
     }
 }
 
-{
-    const x = seq.join(':')(seq.list("1", "2", "3", "4", "5", "6"))
-    if (x !== "1:2:3:4:5:6") { throw x }
-}
+stress()
+
+module.exports = {
 
-{
-    const r = seq.reverse(seq.list(1, 2, 3, 4))
-    const s = array.fromSequence(r)
-    const j = json.stringify(identity)(s)
-    if (j !== '[4,3,2,1]') { throw j }
 }

package/test.js

@@ -82,14 +82,14 @@ const assert_if = c => { if (c) { throw 'assert_if' } }
         constructor: undefined
     }
     const c = o['constructor']
-    console.log(c)
+    //console.log(c)
 }
 
 {
     /** @type {any} */
     const b = '42'
     const r = Number(b)
-    console.log(r)
+    //console.log(r)
 }
 
 {
@@ -106,7 +106,7 @@ const assert_if = c => { if (c) { throw 'assert_if' } }
     //const c = o['propertyIsEnumerable']
     //const c = o['toString']
     const c = o['valueOf']    
-    console.log(c)
+    //console.log(c)
 }
 
 {

package/sequence/operator/README.md

@@ -1,41 +0,0 @@
-# Operator
-
-## Sequence
-
-```ts
-type Sequence<T> = SubSequence<T, undefined>
-```
-
-## SubSequence
-
-```ts
-type SubSequence<T, C> = () => SubSequenceResult<T, C>
-type SubSequenceResult<T, C> = [T, SubSequence<T, C>] | [C]
-```
-
-## The Main FlatScan Operator
-
-```ts
-type FlatScanOperator<T, A> = (value: T) => SubSequence<A, FlatScanOp<T, A>>
-
-const flatScanConcat
-: SubSequence<A, FlatScanOp<T, A>> => Sequence<T> => Sequence<A>
-=> a => b => () => {
-    switch (next(a)) {
-        case [first, tail]: { return [first, flatScanConcat(tail)(b)] }
-        case [operator]: { return flatScan(operator)(b)() }
-    }
-}
-
-const flatScan 
-: FlatScanOperator<T, A> => Sequence<T> => Sequence<A>
-=> operator => sequence => () => {
-    // optimization for `takeWhile`, `find`
-    if (operator === flatScanEmpty) { return [undefined] }
-    //
-    switch (next(s)) {
-        case [first, tail]: { return flatScanConcat(operator(first))(tail)() }
-        case [undefined]: { return [undefined] }        
-    }
-}
-```