functionalscript 0.0.227 → 0.0.231

package/package.json

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

package/sequence/index.js

@@ -34,6 +34,9 @@ const op = require('../function/operator')
 
 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]
 
@@ -58,14 +61,14 @@ 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
+        } else if (aNode instanceof Array) {
+            const [aa, ab] = aNode
             i = () => [aa, () => [ab, b]]
         } else {
-            const { first, tail } = result
+            const { first, tail } = aNode
             return { first, tail: () => [tail, b] }
         }
     }
@@ -136,23 +139,20 @@ const filterMapFn = f => ({first, tail}) => {
 /** @type {<I, O>(f: (value: I) => O|undefined) => (input: Sequence<I>) => Thunk<O>} */
 const filterMap = f => nextMap(filterMapFn(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
+
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const takeWhile = f => input => () => {
-    const result = next(input)
-    if (result === undefined) { return undefined }
+const takeWhile = f => nextMap(takeWhileFn(f))
+
+/** @type {<T>(f: (value: T) => boolean) => (result: ResultOne<T>) => Node<T>} */
+const dropWhileFn = f => result => {
     const { first, tail } = result
-    if (!f(first)) { return undefined }
-    return { first, tail: takeWhile(f)(result.tail) }
+    return f(first) ? nodeOne(dropWhile(f)(tail)) : result
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
-const dropWhile = f => input => () => {
-    const result = next(input)
-    if (result === undefined) { return undefined }
-    const { first, tail } = result
-    if (f(first)) { return nodeOne(dropWhile(f)(tail)) }
-    return result
-}
+const dropWhile = f => nextMap(dropWhileFn(f))
 
 /** @type {<D>(def: D) => <T>(input: Sequence<T>) => D|T} */
 const first = def => input => {
@@ -198,24 +198,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>) => (input: Sequence<T>) => Thunk<A>} */
-const scan = operator => input => () => {
-    const result = next(input)
-    if (result === undefined) { return undefined }
-    const { first, tail } = result
-    const r = operator(first)
-    return { first: r[0], tail: scan(r[1])(tail) }
+/** @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>) => <D>(def: D)=> (input: Sequence<T>) => D|A} */
+/** @type {<T,A>(operator: ScanOperator<T, A>) => (input: Sequence<T>) => Thunk<A>} */
+const scan = operator => nextMap(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))
 
 /**
@@ -224,16 +224,16 @@ 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 => {
+/** @type {<T,A>(operator: ReduceOperator<T, A>) => (init: A) => ScanOperator<T, A>} */
+const scanOperator = operator => init => value => {
     const result = operator(init)(value)
     return scanState(operator)(result)
 }
 
 /** @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
@@ -265,10 +265,18 @@ 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)
+
 module.exports = {
     /** @readonly */
     empty,
     /** @readonly */
+    sequence,
+    /** @readonly */
     iterable,
     /** @readonly */
     next,
@@ -303,7 +311,7 @@ module.exports = {
     /** @readonly */
     dropWhile,
     /** @readonly */
-    scanFunc,
+    scanFunc: scanOperator,
     /** @readonly */
     scanState,
     /** @readonly */
@@ -321,5 +329,7 @@ module.exports = {
     /** @readonly */
     length,
     /** @readonly */
+    reverse,
+    /** @readonly */
     countdown,
 }

package/sequence/test.js

@@ -92,6 +92,16 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
     if (result !== '[[0,"hello"],[1,"world"]]') { throw result }
 }
 
+{
+    const result = stringify(_.reverse([]))
+    if (result !== '[]') { throw result }
+}
+
+{
+    const result = stringify(_.reverse([1,2,3,4,5]))
+    if (result !== '[5,4,3,2,1]') { throw result }
+}
+
 // stress tests
 
 const stress = () => {
@@ -156,6 +166,17 @@ const stress = () => {
         const len = _.length(_.filterMap(() => undefined)(result))
         if (len !== 0) { throw len }
     }
+
+    console.log('dropWhile')
+
+    {
+        // 50_000_000 is too much
+        const n = 20_000_000
+        const result = _.toArray(_.countdown(n))
+        if (result.length !== n) { throw result.length }
+        const len = _.length(_.dropWhile(() => true)(result))
+        if (len !== 0) { throw len }
+    }
 }
 
 // stress()