rubico 2.8.6 → 2.11.0

package/es.js

@@ -1,5 +1,5 @@
 /**
- * Rubico v2.8.6
+ * Rubico v2.10.0
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -601,26 +601,167 @@ const MappingIterator = (iterator, mapper) => ({
   },
 })
 
-const NextIteration = value => ({ value, done: false })
+const promiseRace = Promise.race.bind(Promise)
 
-const symbolAsyncIterator = Symbol.asyncIterator
+class LinkedList {
+  constructor() {
+    this.first = null
+    this.last = null
+    this.length = 0
+  }
 
-const MappingAsyncIterator = (asyncIterator, mapper) => ({
-  [symbolAsyncIterator]() {
-    return this
-  },
-  async next() {
-    const iteration = await asyncIterator.next()
-    if (iteration.done) {
-      return iteration
+  // popFirst() -> firstValue any
+  popFirst() {
+    const first = this.first
+
+    if (first == null) {
+      return undefined
+    }
+
+    if (first.next) {
+      this.first = first.next
+    } else {
+      this.first = null
+    }
+
+    this.length -= 1
+
+    return first.value
+  }
+
+  // append(value any) -> undefined
+  append(value) {
+    const node = { value }
+    if (this.first == null) {
+      this.first = node
+    }
+
+    if (this.last == null) {
+      this.last = node
+    } else {
+      this.last.next = node
+      this.last = node
     }
-    const mapped = mapper(iteration.value)
-    return isPromise(mapped)
-      ? mapped.then(NextIteration)
-      : { value: mapped, done: false }
+
+    this.length += 1
   }
+
+}
+
+const symbolAsyncIterator = Symbol.asyncIterator
+
+const arrayPush = function (array, value) {
+  array.push(value)
+  return array
+}
+
+const sleep = time => new Promise(resolve => {
+  setTimeout(resolve, time)
 })
 
+const MappingAsyncIterator = (asyncIterator, mapper) => {
+  const buffer = new LinkedList()
+
+  let index = -1
+  let consumingAsyncIterator = false
+  let isAsyncIteratorDone = false
+
+  return {
+    [symbolAsyncIterator]() {
+      return this
+    },
+
+    // _consumeAsyncIterator() -> Promise<>
+    async _consumeAsyncIterator() {
+      for await (const item of asyncIterator) {
+        index += 1
+        const mappedItem = mapper(item)
+        buffer.append(mappedItem)
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone) {
+        if (buffer.length > 0) {
+          let value = buffer.popFirst()
+          if (isPromise(value)) {
+            value = await value
+          }
+          return { value, done: false }
+        }
+        await sleep(10)
+      }
+
+      if (buffer.length > 0) {
+        let value = buffer.popFirst()
+        if (isPromise(value)) {
+          value = await value
+        }
+        return { value, done: false }
+      }
+
+      return { value: undefined, done: true }
+    },
+
+  }
+}
+
+const SerialMappingAsyncIterator = (asyncIterator, mapper) => {
+  const buffer = new LinkedList()
+
+  let index = -1
+  let consumingAsyncIterator = false
+  let isAsyncIteratorDone = false
+
+  return {
+    [symbolAsyncIterator]() {
+      return this
+    },
+
+    // _consumeAsyncIterator() -> Promise<>
+    async _consumeAsyncIterator() {
+      for await (const item of asyncIterator) {
+        index += 1
+        let mappedItem = mapper(item)
+        if (isPromise(mappedItem)) {
+          mappedItem = await mappedItem
+        }
+        buffer.append(mappedItem)
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone) {
+        if (buffer.length > 0) {
+          return { value: buffer.popFirst(), done: false }
+        }
+        await sleep(10)
+      }
+
+      if (buffer.length > 0) {
+        return { value: buffer.popFirst(), done: false }
+      }
+
+      return { value: undefined, done: true }
+    },
+
+  }
+}
+
 const isObject = value => {
   if (value == null) {
     return false
@@ -866,8 +1007,6 @@ const tapSync = func => function tapping(...args) {
   return args[0]
 }
 
-const promiseRace = Promise.race.bind(Promise)
-
 const arrayMapPoolAsync = async function (
   array, f, concurrencyLimit, result, index, promises,
 ) {
@@ -1190,9 +1329,6 @@ const _map = function (value, f) {
   if (typeof value.then == 'function') {
     return value.then(f)
   }
-  if (typeof value.map == 'function') {
-    return value.map(f)
-  }
   if (typeof value == 'string' || value.constructor == String) {
     return stringMap(value, f)
   }
@@ -1208,6 +1344,9 @@ const _map = function (value, f) {
   if (typeof value[symbolAsyncIterator] == 'function') {
     return MappingAsyncIterator(value[symbolAsyncIterator](), f)
   }
+  if (typeof value.map == 'function') {
+    return value.map(f)
+  }
   if (value.constructor == Object) {
     return objectMap(value, f)
   }
@@ -1246,27 +1385,36 @@ map.entries = function mapEntries(arg0, arg1) {
     : _mapEntries(arg0, arg1)
 }
 
-const _mapSeries = function (collection, f) {
-  if (isArray(collection)) {
-    return arrayMapSeries(collection, f)
+const _mapSeries = function (functor, f) {
+  if (isArray(functor)) {
+    return arrayMapSeries(functor, f)
   }
-  if (collection == null) {
-    throw new TypeError(`invalid collection ${collection}`)
+  if (functor == null) {
+    throw new TypeError(`invalid functor ${functor}`)
   }
 
-  if (typeof collection == 'string' || collection.constructor == String) {
-    return stringMapSeries(collection, f)
+  if (typeof functor == 'string' || functor.constructor == String) {
+    return stringMapSeries(functor, f)
   }
-  if (collection.constructor == Set) {
-    return setMapSeries(collection, f)
+  if (functor.constructor == Set) {
+    return setMapSeries(functor, f)
   }
-  if (collection.constructor == Map) {
-    return mapMapSeries(collection, f)
+  if (functor.constructor == Map) {
+    return mapMapSeries(functor, f)
   }
-  if (collection.constructor == Object) {
-    return objectMapSeries(collection, f)
+  if (typeof functor[symbolIterator] == 'function') {
+    return MappingIterator(functor[symbolIterator](), f)
   }
-  throw new TypeError(`invalid collection ${collection}`)
+  if (typeof functor[symbolAsyncIterator] == 'function') {
+    return SerialMappingAsyncIterator(functor[symbolAsyncIterator](), f)
+  }
+  if (typeof functor.map == 'function') {
+    return functor.map(f)
+  }
+  if (functor.constructor == Object) {
+    return objectMapSeries(functor, f)
+  }
+  throw new TypeError(`invalid functor ${functor}`)
 }
 
 map.series = function mapSeries(arg0, arg1) {
@@ -1483,15 +1631,15 @@ const _filter = function (value, predicate) {
   if (value.constructor == Map) {
     return mapFilter(value, predicate)
   }
-  if (typeof value.filter == 'function') {
-    return value.filter(predicate)
-  }
   if (typeof value[symbolIterator] == 'function') {
     return FilteringIterator(value[symbolIterator](), predicate)
   }
   if (typeof value[symbolAsyncIterator] == 'function') {
     return FilteringAsyncIterator(value[symbolAsyncIterator](), predicate)
   }
+  if (typeof value.filter == 'function') {
+    return value.filter(predicate)
+  }
   if (value.constructor == Object) {
     return objectFilter(value, predicate)
   }
@@ -1938,11 +2086,6 @@ const transform = function (...args) {
   return _transform(args[0], args[1], args[2])
 }
 
-const arrayPush = function (array, value) {
-  array.push(value)
-  return array
-}
-
 const FlatMappingIterator = function (iterator, flatMapper) {
   let buffer = [],
     bufferIndex = 0
@@ -1977,13 +2120,12 @@ const FlatMappingIterator = function (iterator, flatMapper) {
   }
 }
 
-const sleep = time => new Promise(resolve => {
-  setTimeout(resolve, time)
-})
-
 const FlatMappingAsyncIterator = function (asyncIterator, flatMapper) {
-  const buffer = [],
-    promises = new Set()
+  const buffer = []
+  const promises = new Set()
+
+  let consumingAsyncIterator = false
+  let isAsyncIteratorDone = false
 
   return {
     isAsyncIteratorDone: false,
@@ -1994,38 +2136,48 @@ const FlatMappingAsyncIterator = function (asyncIterator, flatMapper) {
       return '[object FlatMappingAsyncIterator]'
     },
 
-    
-    async next() {
-      while (
-        !this.isAsyncIteratorDone || buffer.length > 0 || promises.size > 0
-      ) {
-        if (!this.isAsyncIteratorDone) {
-          const { value, done } = await asyncIterator.next()
-          if (done) {
-            this.isAsyncIteratorDone = done
-          } else {
-            const monad = flatMapper(value)
-            if (isPromise(monad)) {
-              const bufferLoading =
-                monad.then(curry3(genericReduce, __, arrayPush, buffer))
-              const promise = bufferLoading.then(() => promises.delete(promise))
-              promises.add(promise)
-            } else {
-              const bufferLoading = genericReduce(monad, arrayPush, buffer)
-              if (isPromise(bufferLoading)) {
-                const promise = bufferLoading.then(() => promises.delete(promise))
-                promises.add(promise)
-              }
-            }
+    // _consumeAsyncIterator() -> Promise<>
+    async _consumeAsyncIterator() {
+      for await (const item of asyncIterator) {
+        const monad = flatMapper(item)
+        if (isPromise(monad)) {
+          const bufferLoading =
+            monad.then(curry3(genericReduce, __, arrayPush, buffer))
+          const promise = bufferLoading.then(() => promises.delete(promise))
+          promises.add(promise)
+        } else {
+          const bufferLoading = genericReduce(monad, arrayPush, buffer)
+          if (isPromise(bufferLoading)) {
+            const promise = bufferLoading.then(() => promises.delete(promise))
+            promises.add(promise)
           }
         }
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone || promises.size > 0) {
         if (buffer.length > 0) {
           return { value: buffer.shift(), done: false }
         }
         if (promises.size > 0) {
-          await promiseRace([sleep(1000), ...promises])
+          await promiseRace(promises)
+        } else {
+          await sleep(10)
         }
       }
+
+      if (buffer.length > 0) {
+        return { value: buffer.shift(), done: false }
+      }
+
       return { value: undefined, done: true }
     },
   }
@@ -2121,9 +2273,12 @@ const objectFlatten = function (object) {
 
   for (const key in object) {
     const element = object[key]
+
     if (element == null) {
       continue
-    } else if (typeof element[symbolIterator] == 'function') {
+    }
+
+    if (typeof element[symbolIterator] == 'function') {
       for (const monadElement of element) {
         objectAssign(result, monadElement)
       }
@@ -2384,7 +2539,7 @@ const _iteratorForEachSeriesAsync = async function (iterator, callback) {
 
 const iteratorForEachSeries = function (iterator, callback) {
   let iteration = iterator.next()
-  while (!iterator.done) {
+  while (!iteration.done) {
     const operation = callback(iteration.value)
     if (isPromise(operation)) {
       return operation
@@ -2414,16 +2569,16 @@ const _forEach = function (collection, callback) {
   if (collection == null) {
     return collection
   }
-  if (typeof collection.forEach == 'function') {
-    collection.forEach(callback)
-    return collection
-  }
   if (typeof collection[symbolIterator] == 'function') {
     return iteratorForEach(collection[symbolIterator](), callback)
   }
   if (typeof collection[symbolAsyncIterator] == 'function') {
     return asyncIteratorForEach(collection[symbolAsyncIterator](), callback)
   }
+  if (typeof collection.forEach == 'function') {
+    collection.forEach(callback)
+    return collection
+  }
   if (collection.constructor == Object) {
     return objectForEach(collection, callback)
   }

package/every.js

@@ -84,7 +84,7 @@ const _every = function (collection, predicate) {
  * every(asyncNumbers(), async number => number < 6).then(console.log) // true
  * ```
  *
- * `every` supports a lazy API for composability.
+ * `every` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe([1, 2, 3], [
@@ -93,7 +93,7 @@ const _every = function (collection, predicate) {
  * ])
  * ```
  *
- * Any promises passed in argument position are resolved for their values before further execution.
+ * Any promises passed in data argument position are resolved for their values before further execution.
  *
  * ```javascript [playground]
  * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log) // true

package/filter.js

@@ -70,15 +70,15 @@ const _filter = function (value, predicate) {
   if (value.constructor == Map) {
     return mapFilter(value, predicate)
   }
-  if (typeof value.filter == 'function') {
-    return value.filter(predicate)
-  }
   if (typeof value[symbolIterator] == 'function') {
     return FilteringIterator(value[symbolIterator](), predicate)
   }
   if (typeof value[symbolAsyncIterator] == 'function') {
     return FilteringAsyncIterator(value[symbolAsyncIterator](), predicate)
   }
+  if (typeof value.filter == 'function') {
+    return value.filter(predicate)
+  }
   if (value.constructor == Object) {
     return objectFilter(value, predicate)
   }
@@ -96,14 +96,14 @@ const _filter = function (value, predicate) {
  *   value any,
  *   indexOrKey number|string|any,
  *   filterable Filterable,
- * )=>(condition Promise|boolean)
+ * )=>(booleanResult Promise|boolean)
  *
- * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> result Promise|Filterable
- * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> result Promise|Filterable
+ * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> filteredFilterable Promise|Filterable
+ * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> filteredFilterable Promise|Filterable
  * ```
  *
  * @description
- * Filters out elements from a filterable. Returns a filterable of the same type. The order of the elements in the filterable is preserved.
+ * Filters out items from a filterable, returning a filterable of the same type. The order of the items of the filterable is preserved.
  *
  * The following data types are considered to be filterables:
  *  * `array`
@@ -114,12 +114,12 @@ const _filter = function (value, predicate) {
  *  * `object with .filter method`
  *  * `object`
  *
- * The filtering operation is defined by a given predicate function. The predicate function dictates whether a given element from the filterable should be included in the returned filterable.
+ * The filtering operation is defined by a given predicate function. The predicate function dictates whether a given item from the filterable should be included in the returned filterable.
  *
  * ```javascript
- * const predicate = function (element) {
- *   // condition is the boolean result of the predicate test on element
- *   return condition
+ * const predicate = function (item) {
+ *   // booleanResult is the boolean result of the predicate test on item
+ *   return booleanResult
  * }
  * ```
  *
@@ -127,48 +127,47 @@ const _filter = function (value, predicate) {
  *
  * If the filterable is an array:
  * ```coffeescript [specscript]
- * predicate(element any, index number, filt Array) -> condition Promise|boolean|any
+ * predicate(item any, index number, filterable Array) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a set:
  * ```coffeescript [specscript]
- * predicate(element any, element any, filt Set) -> condition Promise|boolean|any
+ * predicate(item any, item any, filterable Set) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a map:
  * ```coffeescript [specscript]
- * predicate(element any, key any, filt Map) -> condition Promise|boolean|any
+ * predicate(item any, key any, filterable Map) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is a generator:
  * ```coffeescript [specscript]
- * predicate(element any) -> condition Promise|boolean|any
+ * predicate(item any) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is an async generator:
  * ```coffeescript [specscript]
- * predicate(element any) -> condition Promise|boolean|any
+ * predicate(item any) -> booleanResult Promise|boolean|any
  * ```
  *
  * If the filterable is an object with a `.filter` method, the predicate function signature is defined externally.
  *
  * If the filterable is a plain object:
  * ```coffeescript [specscript]
- * predicate(element any, key string, filt Object) -> condition Promise|boolean|any
+ * predicate(item any, key string, filterable Object) -> booleanResult Promise|boolean|any
  * ```
  *
- * `filter` works for arrays.
- *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
  * const array = [1, 2, 3, 4, 5]
  *
- * const result = filter(array, isOdd)
- * console.log(result) // [1, 3, 5]
+ * const filteredArray = filter(array, isOdd)
+ *
+ * console.log(filteredArray)
  * ```
  *
- * If the predicate is asynchronous, the returned promise is concurrently resolved for its boolean condition before continuing with the filtering operation.
+ * If the predicate is asynchronous, it is executed concurrently.
  *
  * ```javascript [playground]
  * const asyncIsOdd = async number => number % 2 == 1
@@ -256,7 +255,7 @@ const _filter = function (value, predicate) {
  * }
  * ```
  *
- * Any promises passed in argument position are resolved for their values before further execution.
+ * Any promises passed in data argument position are resolved for their values before further execution.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1