functionalscript 0.0.230 → 0.0.234

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

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

package/{btree → types/btree}/index.js

@@ -1,4 +1,4 @@
-const cmp = require('../cmp')
+const cmp = require('../function/compare')
 const { index3, index5 } = cmp
 const seq = require('../sequence')
 
@@ -9,7 +9,7 @@ const seq = require('../sequence')
 
 /**
  * @template T
- * @typedef {cmp.Cmp<T>} Cmp
+ * @typedef {cmp.Compare<T>} Cmp
  */
 
 /**
@@ -311,20 +311,20 @@ const values = node => () => {
         switch (node.length) {
             case 1: case 2: { return node }
             case 3: { 
-                return seq.concat(
+                return seq.flat([
                     values(node[0]), 
                     [node[1]], 
                     values(node[2])
-                )
+                ])
             }
             default: {
-                return seq.concat(
+                return seq.flat([
                     values(node[0]),
                     [node[1]],
                     values(node[2]),
                     [node[3]],
                     values(node[4])
-                )
+                ])
             }
         }
     }

package/{btree → types/btree}/test.js

@@ -1,6 +1,6 @@
 const btree = require('.')
 const { setVisitor, values } = btree
-const { cmp } = require('../cmp') 
+const { cmp } = require('../function/compare') 
 const list = require('../sequence')
 
 /** @type {(node: btree.Node<string>) => (value: string) => btree.Node<string>} */

package/{cmp → types/function/compare}/index.js

@@ -1,22 +1,22 @@
-/** @typedef {import('../sequence/array').Index3} Index3 */
-/** @typedef {import('../sequence/array').Index5} Index5 */
+/** @typedef {import('../../array').Index3} Index3 */
+/** @typedef {import('../../array').Index5} Index5 */
 
 /**
  * @template T
- * @typedef {import('../sequence/array').Array2<T>} Array2 
+ * @typedef {import('../../array').Array2<T>} Array2 
  */
 
 /** @typedef {-1|0|1} Sign */
 
 /**
  * @template T
- * @typedef {(_: T) => Sign} Cmp
+ * @typedef {(_: T) => Sign} Compare
  */
 
-/** @type {<T>(cmp: Cmp<T>) => (value: T) => Index3} */
+/** @type {<T>(cmp: Compare<T>) => (value: T) => Index3} */
 const index3 = cmp => value => /** @type {Index3} */ (cmp(value) + 1)
 
-/** @type {<T>(cmp: Cmp<T>) => (v2: Array2<T>) => Index5} */
+/** @type {<T>(cmp: Compare<T>) => (v2: Array2<T>) => Index5} */
 const index5 = cmp => ([v0, v1]) => {
     const _0 = cmp(v0)
     return /** @type {Index5} */ (_0 <= 0 ? _0 + 1 : cmp(v1) + 3)

package/{function → types/function}/operator/index.js

@@ -26,9 +26,20 @@ const addition = a => b => a + b
 /** @type {(value: boolean) => boolean} */
 const logicalNot = v => !v
 
+/**
+ * @template T 
+ * @typedef {(a: T) => (b: T) => boolean} EqualOperator 
+ */
+
 /** @type {<T>(a: T) => (b: T) => boolean} */
 const strictEqual = a => b => a === b
 
+/** @type {ReduceOperator<number, number>} */
+const min = a => b => a < b ? a : b
+
+/** @type {ReduceOperator<number, number>} */
+const max = a => b => a > b ? a : b
+
 module.exports = {
     /** @readonly */
     join,
@@ -38,4 +49,8 @@ module.exports = {
     strictEqual,
     /** @readonly */
     logicalNot,
+    /** @readonly */
+    min,
+    /** @readonly */
+    max,
 }

package/{map → types/map}/index.js

@@ -1,9 +1,9 @@
 const option = require("../option")
 const { getVisitor, setVisitor, values } = require("../btree")
-const { cmp } = require("../cmp")
+const { cmp } = require("../function/compare")
 const seq = require("../sequence")
 
-/** @typedef {import("../cmp").Sign} Sign */
+/** @typedef {import("../function/compare").Sign} Sign */
 
 /**
  * @template T 
@@ -17,7 +17,7 @@ const seq = require("../sequence")
 
 /**
  * @template T
- * @typedef {import("../cmp").Cmp<T>} Cmp
+ * @typedef {import("../function/compare").Compare<T>} Cmp
  */
 
 /**

package/{object → types/object}/index.js

@@ -1,4 +1,3 @@
-const array = require('../sequence/array')
 const seq = require('../sequence')
 const map = require('../map')
 
@@ -25,4 +24,4 @@ module.exports = {
     at,
     /** @readonly */
     sort,
-}
+}

package/types/result/index.js

@@ -0,0 +1,36 @@
+/**
+ * @template T
+ * @typedef {readonly['ok', T]} Ok
+ */
+
+/**
+ * @template E
+ * @typedef {readonly['error', E]} Error
+ */
+
+/**
+ * @template T
+ * @template E
+ * @typedef {Ok<T>|Error<E>} Result
+ */
+
+/** @type {<T>(value: T) => Ok<T>} */
+const ok = value => ['ok', value]
+
+/** @type {<E>(e: E) => Error<E>} */
+const error = e => ['error', e]
+
+/** @type {<T, E>(r: Result<T, E>) => T} */
+const unwrap = result => {
+    if (result[0] === 'error') { throw result[1] }
+    return result[1]
+}
+
+module.exports = {
+    /** @readonly */
+    ok,
+    /** @readonly */
+    error,
+    /** @readonly */
+    unwrap,
+}

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

@@ -1,4 +1,4 @@
-const { compose } = require('../function')
+const { compose, identity } = require('../function')
 const { logicalNot, strictEqual, addition } = require('../function/operator')
 const op = require('../function/operator')
 
@@ -19,7 +19,7 @@ const op = require('../function/operator')
 
 /**
  * @template T
- * @typedef { readonly[Sequence<T>, Sequence<T>]} Concat<T>
+ * @typedef { readonly[Sequence<T>, Sequence<T>] } Concat<T>
  */
 
 /**
@@ -54,6 +54,9 @@ const fromArray = array => {
 /** @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
@@ -61,15 +64,15 @@ const next = sequence => {
         const n = node(i)
         if (!(n instanceof Array)) { return n }
         const [a, b] = n
-        const result = node(a)
-        if (result === undefined) {
+        const aNode = node(a)
+        if (aNode === undefined) {
             i = b
-        } else if (result instanceof Array) {
-            const [aa, ab] = result
-            i = () => [aa, () => [ab, b]]
+        } else if (aNode instanceof Array) {
+            const [aa, ab] = aNode
+            i = concat(aa)(concat(ab)(b))
         } else {
-            const { first, tail } = result
-            return { first, tail: () => [tail, b] }
+            const { first, tail } = aNode
+            return { first, tail: concat(tail)(b) }
         }
     }
 }
@@ -79,7 +82,6 @@ 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
@@ -95,64 +97,73 @@ const toArray = sequence => {
     return Array.from(iterable(sequence))
 }
 
-/** @type {<I, O>(f: (result: ResultOne<I>) => Node<O>) => (input: Sequence<I>) => Thunk<O>} */
-const nextMap = f => input => () => {
+/** @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 flatFn = ({first, tail}) => [first, flat(tail)]
+const flatStep = ({first, tail}) => [first, flat(tail)]
 
 /** @type {<T>(sequence: Sequence<Sequence<T>>) => Thunk<T>} */
-const flat = nextMap(flatFn)
-
-/** @type {<T>(...array: readonly Sequence<T>[]) => Thunk<T>} */
-const concat = (...array) => flat(array)
+const flat = apply(flatStep)
 
 /** @type {<I, O>(f: (value: I) => O) => (result: ResultOne<I>) => Node<O>} */
-const mapFn = f => ({ first, tail }) => ({ first: f(first), tail: map(f)(tail) })
+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 => nextMap(mapFn(f))
+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 filterFn = f => ({ first, tail }) => {
+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 => nextMap(filterFn(f))
+const filter = f => apply(filterStep(f))
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (result: ResultOne<I>) => Node<O>} */
-const filterMapFn = f => ({first, tail}) => {
+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 => nextMap(filterMapFn(f))
+const filterMap = f => apply(filterMapStep(f))
 
 /** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
-const takeWhileFn = f => ({ first, tail }) => f(first) ? { first, tail: takeWhile(f)(tail) } :undefined
+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 => nextMap(takeWhileFn(f))
+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 dropWhileFn = f => result => {
+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 => nextMap(dropWhileFn(f))
+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 => {
@@ -180,14 +191,17 @@ const last = def => 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>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
-const some = f => input => find(false)(x => x)(map(f)(input))
+/** @type {(value: boolean) => boolean} */
+const boolIdentity = identity
+
+/** @type {(sequence: Sequence<boolean>) => boolean} */
+const some = input => find(false)(boolIdentity)(input)
 
-/** @type {<T>(f: (value: T) => boolean) => (sequence: Sequence<T>) => boolean} */
-const every = f => input => !some(compose(f)(logicalNot))(input)
+/** @type {(sequence: Sequence<boolean>) => boolean} */
+const every = input => !some(map(logicalNot)(input))
 
 /** @type {<T>(value: T) => (sequence: Sequence<T>) => boolean} */
-const includes = value => some(strictEqual(value))
+const includes = value => input => some(map(strictEqual(value))(input))
 
 /** @type {(count: number) => Thunk<number>} */
 const countdown = count => () => {
@@ -198,24 +212,24 @@ const countdown = count => () => {
 
 /**
  * @template T,A
- * @typedef {(value: T) => ScanState<T, A>} ScanFunc
+ * @typedef {(value: T) => ScanState<T, A>} ScanOperator
  */
 
 /**
  * @template T,A
- * @typedef {readonly[A, ScanFunc<T, A>]} ScanState
+ * @typedef {readonly[A, ScanOperator<T, A>]} ScanState
  */
 
-/** @type {<T,A>(operator: ScanFunc<T, A>) => (result: ResultOne<T>) => Node<A>} */
+/** @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: ScanFunc<T, A>) => (input: Sequence<T>) => Thunk<A>} */
-const scan = operator => nextMap(scanFn(operator))
+/** @type {<T,A>(operator: ScanOperator<T, A>) => (input: Sequence<T>) => Thunk<A>} */
+const scan = operator => apply(scanFn(operator))
 
-/** @type {<T,A>(operator: ScanFunc<T, A>) => <D>(def: D)=> (input: Sequence<T>) => D|A} */
+/** @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))
 
 /**
@@ -224,16 +238,13 @@ const scanReduce = operator => def => input => last(def)(scan(operator)(input))
  */
 
 /** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanState<T, A>} */
-const scanState = operator => init => [init, scanFunc(operator)(init)]
+const scanState = operator => init => [init, scanOperator(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 {<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(scanFunc(operator)(init))(init)
+const reduce = operator => init => scanReduce(scanOperator(operator)(init))(init)
 
 /** 
  * @template T
@@ -245,6 +256,10 @@ 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))('')
 
@@ -271,9 +286,29 @@ 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 */
-    empty,
     /** @readonly */
     sequence,
     /** @readonly */
@@ -309,9 +344,13 @@ module.exports = {
     /** @readonly */
     takeWhile,
     /** @readonly */
+    take,
+    /** @readonly */
     dropWhile,
     /** @readonly */
-    scanFunc,
+    drop,
+    /** @readonly */
+    scanOperator,
     /** @readonly */
     scanState,
     /** @readonly */
@@ -323,6 +362,10 @@ module.exports = {
     /** @readonly */
     sum,
     /** @readonly */
+    min,
+    /** @readonly */
+    max,
+    /** @readonly */
     join,
     /** @readonly */
     entries,
@@ -331,5 +374,9 @@ module.exports = {
     /** @readonly */
     reverse,
     /** @readonly */
-    countdown,
+    zip,
+    /** @readonly */
+    equal,
+    /** @readonly */
+    countdown,    
 }