rubico 2.8.6 → 2.10.0

package/forEach.js

@@ -24,16 +24,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)
   }
@@ -48,22 +48,19 @@ const _forEach = function (collection, callback) {
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
  * type SyncOrAsyncCallback = (
- *   element any,
+ *   item any,
  *   indexOrKey number|string|any,
- *   iter Iterable
+ *   iterable Iterable
  * )=>Promise|undefined
  *
- * iterable Iterable
- * cb SyncOrAsyncCallback
- *
- * forEach(iterable, cb) -> unmodifiedIterable Promise|Iterable
- * forEach(cb)(iterable) -> unmodifiedIterable Promise|Iterable
+ * forEach(iterable Promise|Iterable, callback SyncOrAsyncCallback) -> iterable Promise|Iterable
+ * forEach(callback SyncOrAsyncCallback)(iterable Iterable) -> iterable Promise|Iterable
  * ```
  *
  * @description
- * Execute a callback function for each element of an iterable, returning the original iterable unmodified.
+ * Executes a callback function for each item of an iterable, returning the original iterable unmodified.
  *
- * The following data types are considered to be iterables:
+ * The following data types are considered to be iterable:
  *  * `array`
  *  * `set`
  *  * `map`
@@ -76,36 +73,44 @@ const _forEach = function (collection, callback) {
  *
  * If the iterable is an array:
  * ```coffeescript [specscript]
- * callback(element any, index number, iter Array) -> Promise|undefined
+ * callback(item any, index number, iterable Array) -> Promise|undefined
  * ```
  *
  * If the iterable is a set:
  * ```coffeescript [specscript]
- * callback(element any, key any, iter Set) -> Promise|undefined
+ * callback(item any, item any, iterable Set) -> Promise|undefined
  * ```
  *
  * If the iterable is a map:
  * ```coffeescript [specscript]
- * callback(element any, key any, filt Map) -> Promise|undefined
+ * callback(item any, key any, iterable Map) -> Promise|undefined
  * ```
  *
  * If the iterable is a generator:
  * ```coffeescript [specscript]
- * callback(element any) -> Promise|undefined
+ * callback(item any) -> Promise|undefined
  * ```
  *
  * If the iterable is an async generator:
  * ```coffeescript [specscript]
- * callback(element any) -> Promise|undefined
+ * callback(item any) -> Promise|undefined
  * ```
  *
- * If the iterable is an object with a `.forEach` method, the callback function signature is defined externally.
- *
  * If the iterable is a plain object:
  * ```coffeescript [specscript]
- * callback(element any, key string, iter Object) -> Promise|undefined
+ * callback(item any, key string, iterable Object) -> Promise|undefined
  * ```
  *
+ * ```javascript [playground]
+ * console.log('array')
+ * forEach([1, 2, 3, 4, 5], num => console.log(num))
+ *
+ * console.log('object')
+ * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num))
+ * ```
+ *
+ * If the iterable is an object with a `.forEach` method, the callback function signature is defined externally.
+ *
  * If the callback function is asynchronous, it is executed concurrently.
  *
  * ```javascript [playground]
@@ -117,37 +122,20 @@ const _forEach = function (collection, callback) {
  * })
  * ```
  *
- * `forEach` works for arrays.
- *
- * ```javascript [playground]
- * forEach([1, 2, 3, 4, 5], num => console.log(num)) // 1 2 3 4 5
- * ```
- *
- * `forEach` works for objects.
- *
- * ```javascript [playground]
- * forEach({ a: 1, b: 2, c: 3 }, num => console.log(num)) // 1 2 3
- * ```
- *
- * Omit the data argument for a composable API
+ * `forEach` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe([1, 2, 3, 4, 5], [
  *   filter(number => number % 2 == 1),
  *   map(number => number ** 2),
- *   forEach(console.log), // 1
- *                         // 9
- *                         // 25
+ *   forEach(console.log),
  * ])
  * ```
  *
- * Any promises passed in argument position are resolved for their values before further execution.
+ * If the iterable is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
  * forEach(Promise.resolve([1, 2, 3]), console.log)
- * // 1
- * // 2
- * // 3
  * ```
  *
  * See also:
@@ -203,16 +191,13 @@ const _forEachSeries = function (collection, callback) {
  * type Iterable = Array|Set|Map|Generator|AsyncGenerator|{ forEach: function }|Object
  *
  * type SyncOrAsyncCallback = (
- *   element any,
+ *   item any,
  *   indexOrKey number|string|any,
  *   iter Iterable
  * )=>Promise|undefined
  *
- * iterable Iterable
- * cb SyncOrAsyncCallback
- *
- * forEach(iterable, cb) -> unmodifiedIterable Promise|Iterable
- * forEach(cb)(iterable) -> unmodifiedIterable Promise|Iterable
+ * forEach.series(iterable Promise|Iterable, callback SyncOrAsyncCallback) -> iterable Promise|Iterable
+ * forEach.series(callback SyncOrAsyncCallback)(iterable Iterable) -> iterable Promise|Iterable
  * ```
  *
  * @description
@@ -224,21 +209,13 @@ const _forEachSeries = function (collection, callback) {
  *     setTimeout(resolve, 1000)
  *   })
  *   console.log(number)
- *   // 1
- *   // 2
- *   // 3
- *   // 4
- *   // 5
  * })
  * ```
  *
- * Any promises passed in argument position are resolved for their values before further execution.
+ * If the iterable is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
  * forEach.series(Promise.resolve([1, 2, 3]), console.log)
- * // 1
- * // 2
- * // 3
  * ```
  *
  * See also:

package/get.js

@@ -45,7 +45,7 @@ const _get = function (object, path, defaultValue) {
  * console.log(value)
  * ```
  *
- * `get` supports a lazy API for composability.
+ * `get` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * const obj = { hello: 'world' }
@@ -103,10 +103,12 @@ const _get = function (object, path, defaultValue) {
  * console.log(get00000ArrayNotation(nested))
  * ```
  *
- * Any promises passed in argument position are resolved for their values before further execution.
+ * If the argument object or default value is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * get(Promise.resolve({ a: 1 }), 'a').then(console.log) // 1
+ * get(Promise.resolve({ a: 1 }), 'a').then(console.log)
+ *
+ * get({}, 'a', Promise.resolve('default-value')).then(console.log)
  * ```
  *
  * See also:

package/gt.js

@@ -56,7 +56,7 @@ const greaterThan = require('./_internal/greaterThan')
  * asyncIsOfLegalAge(juvenile).then(console.log) // false
  * ```
  *
- * `gt` supports a lazy API for composability.
+ * `gt` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe({ value: 1 }, [
@@ -65,7 +65,7 @@ const greaterThan = require('./_internal/greaterThan')
  * ])
  * ```
  *
- * 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]
  * gt(Promise.resolve({ a: 2, b: 1 }), get('a'), get('b')).then(console.log) // true

package/gte.js

@@ -60,7 +60,7 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * asyncIsAtLeast100(101).then(console.log) // true
  * ```
  *
- * `gte` supports a lazy API for composability.
+ * `gte` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe({ value: 1 }, [
@@ -69,7 +69,7 @@ const greaterThanOrEqual = require('./_internal/greaterThanOrEqual')
  * ])
  * ```
  *
- * 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]
  * gte(Promise.resolve({ a: 1, b: 1 }), get('a'), get('b')).then(console.log) // true

package/index.js

@@ -1,5 +1,5 @@
 /**
- * Rubico v2.8.6
+ * Rubico v2.10.0
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -607,26 +607,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
@@ -872,8 +1013,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,
 ) {
@@ -1196,9 +1335,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)
   }
@@ -1214,6 +1350,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)
   }
@@ -1252,27 +1391,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) {
@@ -1489,15 +1637,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)
   }
@@ -1944,11 +2092,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
@@ -1983,13 +2126,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,
@@ -2000,38 +2142,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 }
     },
   }
@@ -2127,9 +2279,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)
       }
@@ -2390,7 +2545,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
@@ -2420,16 +2575,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/lt.js

@@ -58,7 +58,7 @@ const lessThan = require('./_internal/lessThan')
  * asyncIsLessThan3(5).then(console.log) // false
  * ```
  *
- * `lt` supports a lazy API for composability.
+ * `lt` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe({ value: 1 }, [
@@ -67,7 +67,7 @@ const lessThan = require('./_internal/lessThan')
  * ])
  * ```
  *
- * 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]
  * lt(Promise.resolve({ a: 1, b: 2 }), get('a'), get('b')).then(console.log) // true