functionalscript 0.0.222 → 0.0.224

package/package.json

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

package/sequence/index.js

@@ -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>
  */
 
 /**
@@ -34,6 +34,9 @@ const op = require('../function/operator')
 
 const empty = () => undefined
 
+/** @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 */
@@ -48,27 +51,23 @@ const fromArray = array => {
 /** @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] })
-    }
-}
-
 /** @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)
+        const [a, b] = n
+        const result = node(a)
+        if (result === undefined) {
+            i = b
+        } else if (result instanceof Array) {
+            const [aa, ab] = result
+            i = () => [aa, () => [ab, b]]
+        } else {
+            const { first, tail } = result
+            return { first, tail: () => [tail, b] }
+        }
     }
 }
 
@@ -121,7 +120,7 @@ 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()
+    return f(first) ? { first, tail: fTail } : nodeOne(fTail)
 }
 
 /** @type {<T>(f: (value: T) => boolean) => (input: Sequence<T>) => Thunk<T>} */
@@ -131,7 +130,7 @@ const filter = f => nextMap(filterFn(f))
 const filterMapFn = f => ({first, tail}) => {
     const fFirst = f(first)
     const fTail = filterMap(f)(tail)
-    return fFirst === undefined ? fTail() : { first: fFirst, tail: fTail }
+    return fFirst === undefined ? nodeOne(fTail) : { first: fFirst, tail: fTail }
 }
 
 /** @type {<I, O>(f: (value: I) => O|undefined) => (input: Sequence<I>) => Thunk<O>} */
@@ -148,14 +147,11 @@ const takeWhile = f => input => () => {
 
 /** @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 result = next(input)
+    if (result === undefined) { return undefined }
+    const { first, tail } = result
+    if (f(first)) { return nodeOne(dropWhile(f)(tail)) }
+    return result
 }
 
 /** @type {<D>(def: D) => <T>(input: Sequence<T>) => D|T} */
@@ -293,6 +289,8 @@ module.exports = {
     /** @readonly */
     filter,
     /** @readonly */
+    filterMap,
+    /** @readonly */
     find,
     /** @readonly */
     some,

package/sequence/test.js

@@ -95,6 +95,18 @@ const stringify = sequence => json.stringify(sort)(_.toArray(sequence))
 // stress tests
 
 const stress = () => {
+
+    {
+        // 100_000_000 is too much
+        const n = 50_000_000
+        const result = _.toArray(_.countdown(n))
+        if (result.length !== n) { throw result.length }
+        const len = _.length(_.filter(x => x > n)(result))
+        if (len !== 0) { throw len }
+    }
+
+    console.log('first')
+
     {
         // 200_000_000 is too much
         const n = 100_000_000
@@ -133,6 +145,17 @@ const stress = () => {
         }
         const a = _.next(sequence)
     }
+
+    console.log('filterMap')
+
+    {
+        // 100_000_000 is too much
+        const n = 50_000_000
+        const result = _.toArray(_.countdown(n))
+        if (result.length !== n) { throw result.length }
+        const len = _.length(_.filterMap(() => undefined)(result))
+        if (len !== 0) { throw len }
+    }
 }
 
 stress()