functionalscript 0.0.241 → 0.0.242

package/commonjs/package/dependencies/index.js

@@ -1,5 +1,5 @@
 const json = require('../../../json')
-const seq = require('../../../types/sequence')
+const seq = require('../../../types/list')
 
 /** @typedef {readonly[string, string]} DependencyJson */
 

package/commonjs/package/dependencies/test.js

@@ -1,7 +1,4 @@
 const _ = require('.')
-const json = require('../../../json')
-const { sort } = require('../../../types/object')
-const seq = require('../../../types/sequence')
 
 {
     if (!_.isDependenciesJson(undefined)) { throw 'error' }

package/commonjs/path/index.js

@@ -1,9 +1,9 @@
-const seq = require("../../types/sequence")
+const seq = require("../../types/list")
 const option = require("../../types/option")
 const { compose } = require("../../types/function")
 const dep = require("../package/dependencies")
 const { at } = require("../../types/object")
-const pack = require("../package")
+// const pack = require("../package")
 
 /** @typedef {readonly string[]} Items */
 
@@ -18,7 +18,7 @@ const pack = require("../package")
 /** @type {(path: string) => readonly string[]} */
 const split = path => path.split('/')
 
-/** @type {(s: undefined|seq.Sequence<string>) => (items: string) => undefined|seq.Sequence<string>} */
+/** @type {(s: undefined|seq.List<string>) => (items: string) => undefined|seq.List<string>} */
 const normItemsOp = prior => item => {
     if (prior === undefined) { return undefined }
     switch (item) {
@@ -29,17 +29,17 @@ const normItemsOp = prior => item => {
             return result.tail
         }
         default: {
-            return seq.sequence(item)(prior)
+            return seq.nonEmpty(item)(prior)
         }
     }
 }
 
-/** @type {(items: seq.Sequence<string>) => seq.Sequence<string>|undefined} */
+/** @type {(items: seq.List<string>) => seq.List<string>|undefined} */
 const normItems = compose(seq.reduce(normItemsOp)([]))(option.map(seq.reverse))
 
 /** @type {(local: string) => (path: string) => LocalPath|undefined} */
 const parseLocal = local => {
-    /** @type {(path: string) => readonly[boolean, seq.Sequence<string>]} */
+    /** @type {(path: string) => readonly[boolean, seq.List<string>]} */
     const fSeq = path => {
         const pathSeq = split(path)
         switch (seq.first(undefined)(pathSeq)) {
@@ -61,9 +61,9 @@ const parseLocal = local => {
     return f
 }
 
-/** @typedef {readonly[string, seq.Sequence<string>]} IdPath */
+/** @typedef {readonly[string, seq.List<string>]} IdPath */
 
-/** @type {(prior: readonly[string|undefined, seq.Sequence<string>]) => seq.Thunk<IdPath>} */
+/** @type {(prior: readonly[string|undefined, seq.List<string>]) => seq.Thunk<IdPath>} */
 const variants = prior => () => {
     const [a, b] = prior
     const r = seq.next(b)
@@ -88,7 +88,7 @@ const mapDependency = d => ([external, internal]) => {
  * }} Path
  */
 
-/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.Sequence<string>) => Path|undefined} */
+/** @type {(d: dep.DependenciesJson) => (dir: boolean) => (items: seq.List<string>) => Path|undefined} */
 const parseGlobal = d => dir => items => {
     if (d === undefined) { return undefined }
     const v = variants([undefined, items])

package/json/index.js

@@ -1,7 +1,7 @@
-const seq = require('../types/sequence')
+const seq = require('../types/list')
 const object = require('../types/object')
 const array = require('../types/array')
-const { todo } = require('../dev')
+const op = require('../types/function/operator')
 
 /** 
  * @typedef {{
@@ -13,9 +13,9 @@ const { todo } = require('../dev')
 
 /** @typedef {Object|boolean|string|number|null|Array} Unknown */
 
-/** @type {(value: Unknown) => (path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+/** @type {(value: Unknown) => (path: seq.List<string>) => (src: Unknown|undefined) => Unknown} */
 const setProperty = value => {
-    /** @type {(path: seq.Sequence<string>) => (src: Unknown|undefined) => Unknown} */
+    /** @type {(path: seq.List<string>) => (src: Unknown|undefined) => Unknown} */
     const f = path => src => {
         const result = seq.next(path)
         if (result === undefined) { return value }
@@ -26,10 +26,10 @@ const setProperty = value => {
     return f
 }
 
-/** @type {(_: string) => seq.Sequence<string>} */
+/** @type {(_: string) => seq.List<string>} */
 const stringSerialize = input => [JSON.stringify(input)]
 
-/** @type {(_: number) => seq.Sequence<string>} */
+/** @type {(_: number) => seq.List<string>} */
 const numberSerialize = input => [JSON.stringify(input)]
 
 const nullSerialize = ['null']
@@ -38,19 +38,19 @@ const trueSerialize = ['true']
 
 const falseSerialize = ['false']
 
-/** @type {(_: boolean) => seq.Sequence<string>} */
+/** @type {(_: boolean) => seq.List<string>} */
 const boolSerialize = value => value ? trueSerialize : falseSerialize
 
 const colon = [':']
 const comma = [',']
 
-/** @type {seq.FoldOperator<seq.Sequence<string>>} */
+/** @type {op.Fold<seq.List<string>>} */
 const joinOp = a => b => seq.flat([a, comma, b])
 
-/** @type {(input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+/** @type {(input: seq.List<seq.List<string>>) => seq.List<string>} */
 const join = seq.fold(joinOp)([])
 
-/** @type {(open: string) => (close: string) => (input: seq.Sequence<seq.Sequence<string>>) => seq.Sequence<string>} */
+/** @type {(open: string) => (close: string) => (input: seq.List<seq.List<string>>) => seq.List<string>} */
 const list = open => close => {
     const seqOpen = [open]
     const seqClose = [close]
@@ -63,19 +63,19 @@ const arrayList = list('[')(']')
 
 /** @typedef {object.Entry<Unknown>} Entry*/
 
-/** @typedef {(seq.Sequence<Entry>)} Entries */
+/** @typedef {(seq.List<Entry>)} Entries */
 
 /** @typedef {(entries: Entries) => Entries} MapEntries */
 
-/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.Sequence<string>} */
+/** @type {(mapEntries: MapEntries) => (value: Unknown) => seq.List<string>} */
 const serialize = sort => {
-    /** @type {(kv: readonly[string, Unknown]) => seq.Sequence<string>} */
+    /** @type {(kv: readonly[string, Unknown]) => seq.List<string>} */
     const propertySerialize = ([k, v]) => seq.flat([
         stringSerialize(k),
         colon,
         f(v)
     ])
-    /** @type {(object: Object) => seq.Sequence<string>} */
+    /** @type {(object: Object) => seq.List<string>} */
     const objectSerialize = input => {
         const entries = Object.entries(input)
         const sortedEntries = sort(entries)
@@ -83,12 +83,12 @@ const serialize = sort => {
         const serializedEntries = seq.map(propertySerialize)(sortedEntries)
         return objectList(serializedEntries)
     }
-    /** @type {(input: Array) => seq.Sequence<string>} */
+    /** @type {(input: Array) => seq.List<string>} */
     const arraySerialize = input => {
         const serializedEntries = seq.map(f)(input)
         return arrayList(serializedEntries)
     }
-    /** @type {(value: Unknown) => seq.Sequence < string >} */
+    /** @type {(value: Unknown) => seq.List < string >} */
     const f = value => {
         switch (typeof value) {
             case 'boolean': { return boolSerialize(value) }

package/package.json

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

package/test.js

@@ -1,6 +1,6 @@
 const i = require('./')
 
-require('./types/sequence/test')
+require('./types/list/test')
 require('./types/btree/test')
 require('./json/test')
 require('./types/object/test')

package/types/array/index.js

@@ -1,5 +1,5 @@
 const option = require('../option')
-const seq = require('../sequence')
+const seq = require('../list')
 
 /**
  * @template T

package/types/btree/index.js

@@ -1,6 +1,6 @@
 const cmp = require('../function/compare')
 const { index3, index5 } = cmp
-const seq = require('../sequence')
+const seq = require('../list')
 
 /**
  * @template T
@@ -303,7 +303,7 @@ const replaceVisitor = {
     notFound: notFoundGet,
 }
 
-/** @type {<T>(node: Node<T>) => seq.Sequence<T>} */
+/** @type {<T>(node: Node<T>) => seq.List<T>} */
 const values = node => () => {
     const f = () => {
         switch (node.length) {

package/types/btree/test.js

@@ -1,7 +1,7 @@
 const btree = require('.')
 const { setVisitor, values } = btree
 const { cmp } = require('../function/compare') 
-const list = require('../sequence')
+const list = require('../list')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */
 const set = node => value => {
@@ -22,7 +22,7 @@ const test = () => {
     _map = set(_map)('f')
     //
     {
-        /** @type {import('../sequence').Result<string>} */
+        /** @type {list.Result<string>} */
         let _item = list.next(values(_map))
         while (_item !== undefined) {
             _item = list.next(_item.tail)

package/types/function/operator/index.js

@@ -2,44 +2,76 @@
  * @template A
  * @template B
  * @template R
- * @typedef {(a: A) => (b: B) => R} BinaryOperator
+ * @typedef {(a: A) => (b: B) => R} Binary
  */
 
 /**
- * @template R
- * @template T
- * @typedef {BinaryOperator<R, T, R>} ReduceOperator
+ * @template I,O
+ * @typedef {Binary<O, I, O>} Reduce
  */
 
-/** @type {(separator: string) => ReduceOperator<string, string>} */
+/** @type {(separator: string) => Fold<string>} */
 const join = separator => prior => value => `${prior}${separator}${value}`
 
-/** @type {(sum: number) => (value: number) => number} */
+/** @type {Fold<number>} */
 const addition = a => b => a + b
 
 /**
  * @template T
  * @template R
- * @typedef {(value: T) => R} UnaryOperator
+ * @typedef {(value: T) => R} Unary
  */
 
-/** @type {(value: boolean) => boolean} */
+/** @type {Unary<boolean, boolean>} */
 const logicalNot = v => !v
 
 /**
  * @template T 
- * @typedef {(a: T) => (b: T) => boolean} EqualOperator 
+ * @typedef {Binary<T, T, boolean>} Equal 
  */
 
 /** @type {<T>(a: T) => (b: T) => boolean} */
 const strictEqual = a => b => a === b
 
-/** @type {ReduceOperator<number, number>} */
+/** @type {Fold<number>} */
 const min = a => b => a < b ? a : b
 
-/** @type {ReduceOperator<number, number>} */
+/** @type {Fold<number>} */
 const max = a => b => a > b ? a : b
 
+/**
+ * @template I,O
+ * @typedef {(input: I) => readonly[O, Scan<I,O>]} Scan
+ */
+
+/**
+ * @template I,S,O
+ * @typedef {(prior: S) => (input: I) => readonly[O, S]} StateScan
+ */
+
+/** @type {<I, S, O>(op: StateScan<I, S, O>) => (prior: S) => Scan<I, O>} */
+const stateScanToScan = op => prior => i => {
+    const [o, s] = op(prior)(i)
+    return [o, stateScanToScan(op)(s)]
+}
+
+/** @type {<I, O>(reduce: Reduce<I, O>) => (prior: O) => Scan<I, O>} */
+const reduceToScan = reduce => prior => i => {
+    const result = reduce(prior)(i)
+    return [result, reduceToScan(reduce)(result)]
+}
+
+/**
+ * @template T
+ * @typedef {Reduce<T, T>} Fold
+ */
+
+/** @type {<T>(fold: Fold<T>) => Scan<T, T>} */
+const foldToScan = op => init => [init, reduceToScan(op)(init)]
+
+/** @type {(a: number) => () => number} */
+const counter = a => () => a + 1
+
 module.exports = {
     /** @readonly */
     join,
@@ -53,4 +85,12 @@ module.exports = {
     min,
     /** @readonly */
     max,
+    /** @readonly */
+    stateScanToScan,
+    /** @readonly */
+    reduceToScan,
+    /** @readonly */
+    foldToScan,
+    /** @readonly */
+    counter,
 }

package/types/list/index.js

@@ -0,0 +1,372 @@
+const { compose, identity } = require('../function')
+const operator = require('../function/operator')
+const { logicalNot, strictEqual, stateScanToScan, reduceToScan, foldToScan } = require('../function/operator')
+
+/**
+ * @template T
+ * @typedef {NotLazy<T> | Thunk<T>} List
+ */
+
+/**
+ * @template T
+ * @typedef {|
+ *  Result<T> |
+ *  Concat<T> |
+ *  readonly T[]
+ * } NotLazy
+ */
+
+/**
+ * @template T
+ * @typedef {undefined | NonEmpty<T>} Result
+ */
+
+/**
+ * @template T
+ * @typedef {() => List<T>} Thunk
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly isConcat?: undefined
+ *  readonly first: T
+ *  readonly tail: List<T>
+ * }} NonEmpty
+ */
+
+/**
+ * @template T
+ * @typedef {{
+ *  readonly isConcat: true
+ *  readonly a: List<T>
+ *  readonly b: List<T>
+ * }} Concat
+ */
+
+/** @type {<T>(first: T) => (tail: List<T>) => NonEmpty<T>} */
+const nonEmpty = first => tail => ({ first, tail })
+
+/** @type {(i: number) => <T>(array: readonly T[]) => Result<T>} */
+const fromArrayAt = i => array => i < array.length ? nonEmpty(array[i])(() => fromArrayAt(i + 1)(array)) : undefined
+
+/** @type {<T>(array: readonly T[]) => Result<T>} */
+const fromArray = fromArrayAt(0)
+
+/** @type {<T>(a: List<T>) => (b: List<T>) => List<T>} */
+const concat = a => b => b === undefined ? a : ({ isConcat: true, a, b })
+
+/** @type {<T>(list: List<T>) => NotLazy<T> } */
+const trampoline = list => {
+    let i = list
+    while (typeof i === 'function') { i = i() }
+    return i
+}
+
+/** @type {<T>(list: List<T>) => Result<T>} */
+const next = list => {
+    /** @type {readonly[typeof list, typeof list]} */
+    let [a, b] = [list, undefined]
+    while (true) {
+        a = trampoline(a)
+
+        if (a instanceof Array) {
+            a = fromArray(a)
+        } else if (a?.isConcat) {
+            [a, b] = [a.a, concat(a.b)(b)]
+            continue
+        }
+
+        if (a !== undefined) {
+            return nonEmpty(a.first)(concat(a.tail)(b))
+        }
+
+        if (b === undefined) { return undefined }
+
+        [a, b] = [b, undefined]
+    }
+}
+
+/** @type {<T>(list: List<T>) => Iterable<T>} */
+const iterable = list => ({
+    *[Symbol.iterator]() {
+        let i = list
+        while (true) {
+            const r = next(i)
+            if (r === undefined) { return }
+            yield r.first
+            i = r.tail
+        }
+    }
+})
+
+/** @type {<T>(list: List<T>) => readonly T[]} */
+const toArray = list => {
+    const u = trampoline(list)
+    return u instanceof Array ? u : Array.from(iterable(u))
+}
+
+/** @type {<I, O>(step: (n: NonEmpty<I>) => List<O>) => (input: List<I>) => List<O>} */
+const apply = f => input => () => {
+    const n = next(input)
+    if (n === undefined) { return undefined }
+    return f(n)
+}
+
+/** @type {<T>(n: NonEmpty<List<T>>) => List<T>} */
+const flatStep = n => concat(n.first)(flat(n.tail))
+
+/** @type {<T>(list: List<List<T>>) => List<T>} */
+const flat = apply(flatStep)
+
+/** @type {<I, O>(f: (value: I) => O) => (n: NonEmpty<I>) => List<O>} */
+const mapStep = f => n => nonEmpty(f(n.first))(map(f)(n.tail))
+
+/** @type {<I, O>(f: (value: I) => O) => (input: List<I>) => List<O>} */
+const map = f => apply(mapStep(f))
+
+/** @type {<I, O>(f: (value: I) => List<O>) => (input: List<I>) => List<O>} */
+const flatMap = f => compose(map(f))(flat)
+
+/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
+const filterStep = f => n => {
+    const tail = filter(f)(n.tail)
+    return f(n.first) ? nonEmpty(n.first)(tail) : tail
+}
+
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+const filter = f => apply(filterStep(f))
+
+/** @type {<I, O>(f: (value: I) => O|undefined) => (n: NonEmpty<I>) => List<O>} */
+const filterMapStep = f => n => {
+    const [first, tail] = [f(n.first), filterMap(f)(n.tail)]
+    return first === undefined ? tail : nonEmpty(first)(tail)
+}
+
+/** @type {<I, O>(f: (value: I) => O|undefined) => (input: List<I>) => List<O>} */
+const filterMap = f => apply(filterMapStep(f))
+
+/** @type {<T>(f: (value: T) => boolean) => (n: NonEmpty<T>) => List<T>} */
+const takeWhileStep = f => n => f(n.first) ? nonEmpty(n.first)(takeWhile(f)(n.tail)) : undefined
+
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+const takeWhile = f => apply(takeWhileStep(f))
+
+/** @type {(n: number) => <T>(result: NonEmpty<T>) => List<T>} */
+const takeStep = n => ne => 0 < n ? nonEmpty(ne.first)(take(n - 1)(ne.tail)) : undefined
+
+/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
+const take = n => apply(takeStep(n))
+
+/** @type {<T>(f: (value: T) => boolean) => (ne: NonEmpty<T>) => List<T>} */
+const dropWhileStep = f => ne => f(ne.first) ? dropWhile(f)(ne.tail) : ne
+
+/** @type {<T>(f: (value: T) => boolean) => (input: List<T>) => List<T>} */
+const dropWhile = f => apply(dropWhileStep(f))
+
+/** @type {(n: number) => <T>(ne: NonEmpty<T>) => List<T>} */
+const dropStep = n => ne => 0 < n ? drop(n - 1)(ne.tail) : ne
+
+/** @type {(n: number) => <T>(input: List<T>) => List<T>} */
+const drop = n => apply(dropStep(n))
+
+/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
+const first = def => input => {
+    const result = next(input)
+    if (result === undefined) { return def }
+    return result.first
+}
+
+/** @type {<D>(def: D) => <T>(input: List<T>) => D|T} */
+const last = def => input => {
+    /** @typedef {typeof input extends List<infer T> ? T : never} T */
+    let i = nonEmpty(/** @type {(typeof def)|T} */(def))(input)
+    while (true) {
+        const result = next(i.tail)
+        if (result === undefined) {
+            return i.first
+        }
+        i = result
+    }
+}
+
+/** @type {<D>(def: D) => <T>(f: (value: T) => boolean) => (input: List<T>) => D|T} */
+const find = def => f => input => first(def)(filter(f)(input))
+
+/** @type {(input: List<boolean>) => boolean} */
+const some = input => find
+    (false)
+    (/** @type {(_: boolean) => boolean} */(identity))
+    (input)
+
+/** @type {(input: List<boolean>) => boolean} */
+const every = input => !some(map(logicalNot)(input))
+
+/** @type {<T>(value: T) => (sequence: List<T>) => boolean} */
+const includes = value => input => some(map(strictEqual(value))(input))
+
+/** @type {(count: number) => Thunk<number>} */
+const countdown = count => () => {
+    if (count <= 0) { return undefined }
+    const first = count - 1
+    return nonEmpty(first)(countdown(first))
+}
+
+/** @type {<T>(list: List<T>) => List<T>} */
+const cycle = list => () => {
+    const i = next(list)
+    return i === undefined ? undefined : nonEmpty(i.first)(concat(i.tail)(cycle(list)))
+}
+
+/** @type {<I, O>(op: operator.Scan<I, O>) => (ne: NonEmpty<I>) => List<O>} */
+const scanStep = op => ne => {
+    const [o, newOp] = op(ne.first)
+    return nonEmpty(o)(scan(newOp)(ne.tail))
+}
+
+/** @type {<I, O>(op: operator.Scan<I, O>) => (input: List<I>) => List<O>} */
+const scan = op => apply(scanStep(op))
+
+/** @type {<I, S, O>(op: operator.StateScan<I, S, O>) => (init: S) => (input: List<I>) => List<O>} */
+const stateScan = op => init => scan(stateScanToScan(op)(init))
+
+/** @type {<I,O>(op: operator.Reduce<I, O>) => (init: O) => (input: List<I>) => List<O>} */
+const reduceScan = op => init => scan(reduceToScan(op)(init))
+
+/** @type {<I,O>(op: operator.Reduce<I, O>) => (init: O) => (input: List<I>) => O} */
+const reduce = op => init => input => last(init)(reduceScan(op)(init)(input))
+
+/** @type {<T>(op: operator.Fold<T>) => <D>(def: D) => (input: List<T>) => D|T} */
+const fold = op => def => input => last(def)(scan(foldToScan(op))(input))
+
+const sum = fold(operator.addition)(0)
+
+const min = fold(operator.min)(undefined)
+
+const max = fold(operator.max)(undefined)
+
+/** @type {(separator: string) => (input: List<string>) => string} */
+const join = separator => fold(operator.join(separator))('')
+
+/** @type {<T>(input: List<T>) => number} */
+const length = reduce(operator.counter)(0)
+
+/**
+ * @template T
+ * @typedef {readonly[number, T]} Entry
+ */
+
+/** @type {(index: number) => <T>(value: T) => readonly[Entry<T>, number]} */
+const entryOperator = index => value => [[index, value], index + 1]
+
+/** @type {<T>(input: List<T>) => List<Entry<T>>} */
+const entries = (input) => {
+    /** @typedef {typeof input extends List<infer T> ? T : never} T */
+    return stateScan(/** @type {operator.StateScan<T, Number, Entry<T>>} */(entryOperator))(0)(input)
+}
+
+/** @type {<T>(prior: List<T>) => (value: T) => List<T>} */
+const reverseOperator = prior => value => nonEmpty(value)(prior)
+
+/** @type {<T>(input: List<T>) => List<T>} */
+const reverse = reduce(reverseOperator)(undefined)
+
+/** @type {<A>(a: A) => <B>(b: B) => readonly[A, B]} */
+const tuple2 = a => b => [a, b]
+
+/** @type {<A>(a: List<A>) => <B>(b: List<B>) => List<readonly[A, B]>} */
+const zip = a => b => () => {
+    const aResult = next(a)
+    if (aResult === undefined) { return undefined }
+    const bResult = next(b)
+    if (bResult === undefined) { return undefined }
+    return nonEmpty(tuple2(aResult.first)(bResult.first))(zip(aResult.tail)(bResult.tail))
+}
+
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => List<boolean>} */
+const equalZip = e => a => b => () => {
+    const [aResult, bResult] = [next(a), next(b)]
+    return aResult === undefined || bResult === undefined
+        ? nonEmpty(aResult === bResult)(undefined)
+        : nonEmpty(e(aResult.first)(bResult.first))(equalZip(e)(aResult.tail)(bResult.tail))
+}
+
+/** @type {<T>(e: operator.Equal<T>) => (a: List<T>) => (b: List<T>) => boolean} */
+const equal = e => a => b => every(equalZip(e)(a)(b))
+
+module.exports = {
+    /** @readonly */
+    empty: undefined,
+    /** @readonly */
+    nonEmpty,
+    /** @readonly */
+    concat,
+    /** @readonly */
+    next,
+    /** @readonly */
+    iterable,
+    /** @readonly */
+    toArray,
+    /** @readonly */
+    flat,
+    /** @readonly */
+    map,
+    /** @readonly */
+    flatMap,
+    /** @readonly */
+    filter,
+    /** @readonly */
+    filterMap,
+    /** @readonly */
+    takeWhile,
+    /** @readonly */
+    take,
+    /** @readonly */
+    dropWhile,
+    /** @readonly */
+    drop,
+    /** @readonly */
+    first,
+    /** @readonly */
+    last,
+    /** @readonly */
+    find,
+    /** @readonly */
+    some,
+    /** @readonly */
+    every,
+    /** @readonly */
+    includes,
+    /** @readonly */
+    countdown,
+    /** @readonly */
+    cycle,
+    /** @readonly */
+    scan,
+    /** @readonly */
+    stateScan,
+    /** @readonly */
+    reduceScan,
+    /** @readonly */
+    reduce,
+    /** @readonly */
+    fold,
+    /** @readonly */
+    sum,
+    /** @readonly */
+    min,
+    /** @readonly */
+    max,
+    /** @readonly */
+    join,
+    /** @readonly */
+    length,
+    /** @readonly */
+    entries,
+    /** @readonly */
+    reverse,
+    /** @readonly */
+    zip,
+    /** @readonly */
+    equal,
+}

package/types/{sequence → list}/test.js

@@ -1,11 +1,16 @@
 const _ = require('.')
 const json = require('../../json')
 const { sort } = require('../object')
-const { addition, strictEqual } = require('../function/operator')
+const { addition, strictEqual, foldToScan } = require('../function/operator')
 
-/** @type {(sequence: _.Sequence<json.Unknown>) => string} */
+/** @type {(sequence: _.List<json.Unknown>) => string} */
 const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
+{
+    const x = stringify(_.toArray(_.take(10)(_.cycle([1, 2, 3]))))
+    if (x !== '[1,2,3,1,2,3,1,2,3,1]') { throw x }
+}
+
 {
     const s = stringify([1, 2, 3])
     if (s !== '[1,2,3]') { throw s }
@@ -84,7 +89,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const op = _.scanState(addition)
+    const op = foldToScan(addition)
     const result = stringify(_.scan(op)([2, 3, 4, 5]))
     if (result !== '[2,5,9,14]') { throw result }
 }
@@ -130,7 +135,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 }
 
 {
-    const result = stringify(_.reverse([1,2,3,4,5]))
+    const result = stringify(_.reverse([1, 2, 3, 4, 5]))
     if (result !== '[5,4,3,2,1]') { throw result }
 }
 
@@ -146,7 +151,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 {
     const result = _.some(_.map(x => x > 5)([0, 1, 7]))
-    if (!result) { throw result}
+    if (!result) { throw result }
 }
 
 {
@@ -176,7 +181,7 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 
 {
     const result = _.equal(strictEqual)([1])([2, 3])
-    if (result) { throw result}
+    if (result) { throw result }
 }
 
 {
@@ -214,8 +219,8 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 const stress = () => {
 
     {
-        // 100_000_000 is too much
-        const n = 50_000_000
+        // 200_000_000 is too much
+        const n = 100_000_000
         const result = _.toArray(_.countdown(n))
         if (result.length !== n) { throw result.length }
         const len = _.length(_.filter(x => x > n)(result))
@@ -225,26 +230,30 @@ const stress = () => {
     console.log('first')
 
     {
-        // 200_000_000 is too much
-        const n = 100_000_000
+        // 100_000_000 is too much
+        const n = 50_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 }
     }
 
+    console.log('concat back')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
-        // 10_000_000 is too much
-        for (let i = 0; i < 5_000_000; ++i) {
+        // 20_000_000 is too much
+        for (let i = 0; i < 10_000_000; ++i) {
             sequence = _.concat(sequence)([i])
         }
         const r = _.toArray(sequence)
     }
 
+    console.log('flat to Array')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 4_000_000 is too much
         for (let i = 0; i < 2_000_000; ++i) {
@@ -253,18 +262,22 @@ const stress = () => {
         const r = _.toArray(sequence)
     }
 
+    console.log('flat next')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 5_000_000 is too much
-        for (let i = 0; i < 2_000_000; ++i) {
+        for (let i = 0; i < 4_000_000; ++i) {
             sequence = _.flat([sequence, [i]])
         }
         const a = _.next(sequence)
     }
 
+    console.log('concat front')
+
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 20_000_000 is too much
         for (let i = 0; i < 10_000_000; ++i) {
@@ -274,7 +287,7 @@ const stress = () => {
     }
 
     {
-        /** @type {_.Sequence<number>} */
+        /** @type {_.List<number>} */
         let sequence = []
         // 10_000_000 is too much
         for (let i = 0; i < 5_000_000; ++i) {
@@ -306,7 +319,7 @@ const stress = () => {
     }
 }
 
-// stress()
+stress()
 
 module.exports = {
 

package/types/map/index.js

@@ -3,7 +3,7 @@ const btree = require('../btree')
 const { getVisitor, setVisitor, values } = require("../btree")
 const compare = require("../function/compare")
 const { cmp } = require("../function/compare")
-const seq = require("../sequence")
+const seq = require("../list")
 
 /** @typedef {compare.Sign} Sign */
 
@@ -54,15 +54,15 @@ const set = name => value => map =>  {
     }
 }
 
-/** @type {<T>(map: Map<T>) => seq.Sequence<Entry<T>>} */
+/** @type {<T>(map: Map<T>) => seq.List<Entry<T>>} */
 const entries = map => map === undefined ? [] : values(map)
 
 /** @type {<T>(map: Map<T>) => (entry: Entry<T>) => Map<T>} */
 const setOp = map => ([name, value]) => set(name)(value)(map)
 
-/** @type {<T>(entries: seq.Sequence<Entry<T>>) => Map<T>} */
+/** @type {<T>(entries: seq.List<Entry<T>>) => Map<T>} */
 const fromEntries = entries => {
-    /** @typedef {typeof entries extends seq.Sequence<Entry<infer T>> ? T : never} T */    
+    /** @typedef {typeof entries extends seq.List<Entry<infer T>> ? T : never} T */    
     return seq.reduce(setOp)(/** @type {Map<T>} */(undefined))(entries)
 }
 

package/types/map/test.js

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

package/types/object/index.js

@@ -1,6 +1,5 @@
-const seq = require('../sequence')
+const seq = require('../list')
 const map = require('../map')
-const { compose } = require('../function')
 
 /**
  * @template T
@@ -17,7 +16,7 @@ const { compose } = require('../function')
 /** @type {(name: string) => <T>(object: Map<T>) => T|undefined} */
 const at = name => object => Object.getOwnPropertyDescriptor(object, name)?.value
 
-/** @type {<T>(entries: seq.Sequence<Entry<T>>) => seq.Sequence<Entry<T>>} */
+/** @type {<T>(entries: seq.List<Entry<T>>) => seq.List<Entry<T>>} */
 const sort = entries => map.entries(map.fromEntries(entries))
 
 module.exports = {

package/types/sequence/README.md

@@ -1,68 +0,0 @@
-# Sequences
-
-Sequence types:
-
-- Sequence
-- Array
-- 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
-
-- `length: Sequence<infer T> => number`
-- `at: number => Sequence<infer T> = T|undefined`
-- `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`
-- `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.
-
-- `keys: Sequence<T> => Sequence<string>`
-- `values: Sequence<infer T> => Sequence<T>`
-
-## Prohibited Array Operations
-
-- `copyWithin`
-- `fill`
-- `pop`
-- `push`
-- `reverse`
-- `shift`
-- `sort`
-- `splice`
-- `unshift`

package/types/sequence/index.js

@@ -1,382 +0,0 @@
-const { compose, identity } = require('../function')
-const { logicalNot, strictEqual, addition } = require('../function/operator')
-const op = require('../function/operator')
-
-/**
- * @template T
- * @typedef { readonly T[] | Thunk<T> } Sequence<T>
- */
-
-/**
- * @template T
- * @typedef { () => Node<T> } Thunk
- */
-
-/**
- * @template T
- * @typedef { Result<T> | Concat<T> } Node<T>
- */
-
-/**
- * @template T
- * @typedef { readonly[Sequence<T>, Sequence<T>] } Concat<T>
- */
-
-/**
- * @template T
- * @typedef { undefined | ResultOne<T> } Result
- */
-
-/**
- * @template T
- * @typedef {{ readonly first: T, readonly tail: Sequence<T> }} ResultOne
- */
-
-const empty = () => undefined
-
-/** @type {<T>(first: T) => (tail: Sequence<T>) => Sequence<T>} */
-const sequence = first => tail => () => ({ first, tail })
-
-/** @type {<T>(sequence: Sequence<T>) => Node<T>} */
-const nodeOne = sequence => [empty, sequence]
-
-/** @type {<T>(array: readonly T[]) => Result<T>} */
-const fromArray = array => {
-    /** @typedef {typeof array extends readonly(infer T)[] ? T : never} T */
-    /** @type {(index: number) => Result<T>} */
-    const at = index => {
-        if (array.length <= index) { return undefined }
-        return { first: array[index], tail: () => at(index + 1) }
-    }
-    return at(0)
-}
-
-/** @type {<T>(sequence: Sequence<T>) => Node<T>} */
-const node = sequence => sequence instanceof Array ? fromArray(sequence) : sequence()
-
-/** @type {<T>(a: Sequence<T>) => (b: Sequence<T>) => Thunk<T>} */
-const concat = a => b => () => [a, b]
-
-/** @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 }
-        const [a, b] = n
-        const aNode = node(a)
-        if (aNode === undefined) {
-            i = b
-        } else if (aNode instanceof Array) {
-            const [aa, ab] = aNode
-            i = concat(aa)(concat(ab)(b))
-        } else {
-            const { first, tail } = aNode
-            return { first, tail: concat(tail)(b) }
-        }
-    }
-}
-
-/** @type {<T>(sequence: Sequence<T>) => Iterable<T>} */
-const iterable = sequence => ({
-    *[Symbol.iterator]() {
-        let i = sequence
-        while (true) {
-            const n = next(i)
-            if (n === undefined) { return }
-            const { first, tail } = n
-            yield first
-            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>(step: (result: ResultOne<I>) => Node<O>) => (input: Sequence<I>) => Thunk<O>} */
-const apply = f => input => () => {
-    const n = next(input)
-    if (n === undefined) { return undefined }
-    return f(n)
-}
-
-/** @type {<T>(result: ResultOne<Sequence<T>>) => Node<T>} */
-const flatStep = ({first, tail}) => [first, flat(tail)]
-
-/** @type {<T>(sequence: Sequence<Sequence<T>>) => Thunk<T>} */
-const flat = apply(flatStep)
-
-/** @type {<I, O>(f: (value: I) => O) => (result: ResultOne<I>) => Node<O>} */
-const mapStep = 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 => apply(mapStep(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 filterStep = f => ({ first, tail }) => {
-    const fTail = filter(f)(tail)
-    return f(first) ? { first, tail: fTail } : nodeOne(fTail)
-}
-
-/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const filter = f => apply(filterStep(f))
-
-/** @type {<I, O>(f: (value: I) => O|undefined) => (result: ResultOne<I>) => Node<O>} */
-const filterMapStep = f => ({first, tail}) => {
-    const fFirst = f(first)
-    const fTail = filterMap(f)(tail)
-    return fFirst === undefined ? nodeOne(fTail) : { first: fFirst, tail: fTail }
-}
-
-/** @type {<I, O>(f: (value: I) => O|undefined) => (input: Sequence<I>) => Thunk<O>} */
-const filterMap = f => apply(filterMapStep(f))
-
-/** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const takeWhileStep = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } :undefined
-
-/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const takeWhile = f => apply(takeWhileStep(f))
-
-/** @type {(n: number) => <T>(result: ResultOne<T>) => Node<T>} */
-const takeStep = n => ({ first, tail }) => 0 < n ? { first, tail: take(n - 1)(tail) } : undefined
-
-/** @type {(n: number) => <T>(result: Sequence<T>) => Sequence<T>} */
-const take = n => apply(takeStep(n))
-
-/** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const dropWhileStep = f => result => {
-    const { first, tail } = result
-    return f(first) ? nodeOne(dropWhile(f)(tail)) : result
-}
-
-/** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const dropWhile = f => apply(dropWhileStep(f))
-
-/** @type {(n: number) => <T>(result: ResultOne<T>) => Node<T>} */
-const dropFn = n => result => 0 < n ? nodeOne(drop(n - 1)(result.tail)) : result
-
-/** @type {(n: number) => <T>(result: Sequence<T>) => Sequence<T>} */
-const drop = n => apply(dropFn(n))
-
-/** @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 {<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
-    while (true) {
-        const result = next(i)
-        if (result === undefined) {
-            return r
-        }
-        r = result.first
-        i = result.tail
-    }
-}
-
-/** @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 {(value: boolean) => boolean} */
-const boolIdentity = identity
-
-/** @type {(sequence: Sequence<boolean>) => boolean} */
-const some = input => find(false)(boolIdentity)(input)
-
-/** @type {(sequence: Sequence<boolean>) => boolean} */
-const every = input => !some(map(logicalNot)(input))
-
-/** @type {<T>(value: T) => (sequence: Sequence<T>) => boolean} */
-const includes = value => input => some(map(strictEqual(value))(input))
-
-/** @type {(count: number) => Thunk<number>} */
-const countdown = count => () => {
-    if (count <= 0) { return undefined }
-    const first = count - 1
-    return { first, tail: countdown(first) }
-}
-
-/**
- * @template T,A
- * @typedef {(value: T) => ScanState<T, A>} ScanOperator
- */
-
-/**
- * @template T,A
- * @typedef {readonly[A, ScanOperator<T, A>]} ScanState
- */
-
-/** @type {<T,A>(operator: ScanOperator<T, A>) => (result: ResultOne<T>) => Node<A>} */
-const scanFn = operator => ({first, tail}) => {
-    const [value, nextOperator] = operator(first)
-    return { first: value, tail: scan(nextOperator)(tail) }
-}
-
-/** @type {<T,A>(operator: ScanOperator<T, A>) => (input: Sequence<T>) => Thunk<A>} */
-const scan = operator => apply(scanFn(operator))
-
-/** @type {<T,A>(operator: ScanOperator<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, scanOperator(operator)(init)]
-
-/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanOperator<T, A>} */
-const scanOperator = operator => init => value => scanState(operator)(operator(init)(value))
-
-/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => (input: Sequence<T>) => A} */
-const reduce = operator => init => scanReduce(scanOperator(operator)(init))(init)
-
-/** 
- * @template T
- * @typedef {ReduceOperator<T, T>} FoldOperator
- */
-
-/** @type {<T>(operator: FoldOperator<T>) => <D>(def: D) => (input: Sequence<T>) => D|T} */
-const fold = operator => def => scanReduce(scanState(operator))(def)
-
-const sum = fold(addition)(0)
-
-const min = fold(op.min)(undefined)
-
-const max = fold(op.max)(undefined)
-
-/** @type {(separator: string) => (input: Sequence<string>) => string} */
-const join = separator => fold(op.join(separator))('')
-
-/** @type {(a: number) => () => number} */
-const counter = a => () => a + 1
-
-/** @type {<T>(input: Sequence<T>) => number} */
-const length = reduce(counter)(0)
-
-/**
- * @template T
- * @typedef {readonly[number, T]} Entry
- */
-
-/** @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))
-
-/** @type {<T>(prior: Sequence<T>) => (value: T) => Sequence<T>} */
-const reverseOp = prior => value => sequence(value)(prior)
-
-/** @type {<T>(input: Sequence<T>) => Sequence<T>} */
-const reverse = reduce(reverseOp)(empty)
-
-/** @type {<A>(a: Sequence<A>) => <B>(b: Sequence<B>) => Thunk<readonly[A, B]>} */
-const zip = a => b => () => {
-    const aResult = next(a)
-    if (aResult === undefined) { return undefined }
-    const bResult = next(b)
-    if (bResult === undefined) { return undefined }
-    return { first: [aResult.first, bResult.first], tail: zip(aResult.tail)(bResult.tail) }
-}
-
-/** @type {<T>(e: op.EqualOperator<T>) => (a: Sequence<T>) => (b: Sequence<T>) => Thunk<boolean>} */
-const equalZip = e => a => b => () => {
-    const aResult = next(a)
-    const bResult = next(b)
-    if (aResult === undefined || bResult === undefined) {
-        return { first: aResult === bResult, tail: empty }
-    }
-    return { first: e(aResult.first)(bResult.first), tail: equalZip(e)(aResult.tail)(bResult.tail) }
-}
-
-/** @type {<T>(e: op.EqualOperator<T>) => (a: Sequence<T>) => (b: Sequence<T>) => boolean} */
-const equal = e => a => b => every(equalZip(e)(a)(b))
-
-module.exports = {
-    /** @readonly */
-    sequence,
-    /** @readonly */
-    iterable,
-    /** @readonly */
-    next,
-    /** @readonly */
-    toArray,
-    /** @readonly */
-    flat,
-    /** @readonly */
-    last,
-    /** @readonly */
-    concat,
-    /** @readonly */
-    first,
-    /** @readonly */
-    map,
-    /** @readonly */
-    flatMap,
-    /** @readonly */
-    filter,
-    /** @readonly */
-    filterMap,
-    /** @readonly */
-    find,
-    /** @readonly */
-    some,
-    /** @readonly */
-    every,
-    /** @readonly */
-    includes,    
-    /** @readonly */
-    takeWhile,
-    /** @readonly */
-    take,
-    /** @readonly */
-    dropWhile,
-    /** @readonly */
-    drop,
-    /** @readonly */
-    scanOperator,
-    /** @readonly */
-    scanState,
-    /** @readonly */
-    scan,
-    /** @readonly */
-    reduce,
-    /** @readonly */
-    fold,
-    /** @readonly */
-    sum,
-    /** @readonly */
-    min,
-    /** @readonly */
-    max,
-    /** @readonly */
-    join,
-    /** @readonly */
-    entries,
-    /** @readonly */
-    length,
-    /** @readonly */
-    reverse,
-    /** @readonly */
-    zip,
-    /** @readonly */
-    equal,
-    /** @readonly */
-    countdown,    
-}