rubico 2.11.0 → 2.13.0

package/es.js

@@ -1,5 +1,5 @@
 /**
- * Rubico v2.10.0
+ * Rubico v2.13.0
  * https://rubico.land/
  *
  * © Richard Yufei Tong, King of Software
@@ -368,7 +368,8 @@ const functionArrayAllSeries = function (funcs, args) {
   const funcsLength = funcs.length, result = []
   let funcsIndex = -1
   while (++funcsIndex < funcsLength) {
-    const resultElement = funcs[funcsIndex](...args)
+    const f = funcs[funcsIndex]
+    const resultElement = typeof f == 'function' ? f(...args) : f
     if (isPromise(resultElement)) {
       return resultElement.then(funcConcat(
         curry3(objectSet, result, funcsIndex, __),
@@ -379,6 +380,90 @@ const functionArrayAllSeries = function (funcs, args) {
   return result
 }
 
+// argument resolver for curry5
+const curry5ResolveArg0 = (
+  baseFunc, arg1, arg2, arg3, arg4,
+) => function arg0Resolver(arg0) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg1 = (
+  baseFunc, arg0, arg2, arg3, arg4,
+) => function arg1Resolver(arg1) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg2 = (
+  baseFunc, arg0, arg1, arg3, arg4,
+) => function arg2Resolver(arg2) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg3 = (
+  baseFunc, arg0, arg1, arg2, arg4,
+) => function arg3Resolver(arg3) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+// argument resolver for curry5
+const curry5ResolveArg4 = (
+  baseFunc, arg0, arg1, arg2, arg3,
+) => function arg3Resolver(arg4) {
+  return baseFunc(arg0, arg1, arg2, arg3, arg4)
+}
+
+const curry5 = function (baseFunc, arg0, arg1, arg2, arg3, arg4) {
+  if (arg0 == __) {
+    return curry5ResolveArg0(baseFunc, arg1, arg2, arg3, arg4)
+  }
+  if (arg1 == __) {
+    return curry5ResolveArg1(baseFunc, arg0, arg2, arg3, arg4)
+  }
+  if (arg2 == __) {
+    return curry5ResolveArg2(baseFunc, arg0, arg1, arg3, arg4)
+  }
+  if (arg3 == __) {
+    return curry5ResolveArg3(baseFunc, arg0, arg1, arg2, arg4)
+  }
+  return curry5ResolveArg4(baseFunc, arg0, arg1, arg2, arg3)
+}
+
+const asyncFunctionObjectAllSeries = async function (funcs, args, result, keys, keysIndex) {
+  const keysLength = keys.length
+  while (++keysIndex < keysLength) {
+    const key = keys[keysIndex]
+    const f = funcs[key]
+    let resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
+      resultElement = await resultElement
+    }
+    result[key] = resultElement
+  }
+  return result
+}
+
+const functionObjectAllSeries = function (funcs, args) {
+  const result = {}
+  const keys = Object.keys(funcs)
+  const keysLength = keys.length
+  let keysIndex = -1
+  while (++keysIndex < keysLength) {
+    const key = keys[keysIndex]
+    const f = funcs[key]
+    const resultElement = typeof f == 'function' ? f(...args) : f
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
+        curry3(objectSet, result, key, __),
+        curry5(asyncFunctionObjectAllSeries, funcs, args, __, keys, keysIndex)))
+    }
+    result[key] = resultElement
+  }
+  return result
+}
+
 const functionObjectAll = function (funcs, args) {
   const result = {}, promises = []
   for (const key in funcs) {
@@ -435,14 +520,33 @@ const all = function (...args) {
 }
 
 all.series = function allSeries(...args) {
-  const funcs = args.pop()
-  if (args.length == 0) {
-    return curryArgs2(functionArrayAllSeries, funcs, __)
+  if (args.length == 1) {
+    const resolversOrValues = args[0]
+    if (isPromise(resolversOrValues)) {
+      return resolversOrValues.then(_allValues)
+    }
+    if (areAllValuesNonfunctions(resolversOrValues)) {
+      return _allValues(resolversOrValues)
+    }
+    return isArray(resolversOrValues)
+      ? curryArgs2(functionArrayAllSeries, resolversOrValues, __)
+      : curryArgs2(functionObjectAllSeries, resolversOrValues, __)
   }
-  if (areAnyValuesPromises(args)) {
-    return promiseAll(args).then(curry2(functionArrayAllSeries, funcs, __))
+
+  const resolversOrValues = args[args.length - 1]
+  const argValues = args.slice(0, -1)
+
+  if (areAnyValuesPromises(argValues)) {
+    return isArray(resolversOrValues)
+      ? promiseAll(argValues)
+        .then(curry2(functionArrayAllSeries, resolversOrValues, __))
+      : promiseAll(argValues)
+        .then(curry2(functionObjectAllSeries, resolversOrValues, __))
   }
-  return functionArrayAllSeries(funcs, args)
+
+  return isArray(resolversOrValues)
+    ? functionArrayAllSeries(resolversOrValues, argValues)
+    : functionObjectAllSeries(resolversOrValues, argValues)
 }
 
 const objectAssign = Object.assign
@@ -1474,26 +1578,64 @@ const FilteringIterator = (iterator, predicate) => ({
   },
 })
 
-const FilteringAsyncIterator = (asyncIterator, predicate) => ({
-  isAsyncIteratorDone: false,
-  [symbolAsyncIterator]() {
-    return this
-  },
-  async next() {
-    while (!this.isAsyncIteratorDone) {
-      const { value, done } = await asyncIterator.next()
-      if (done) {
-        this.isAsyncIteratorDone = true
-      } else {
-        const predication = predicate(value)
-        if (isPromise(predication) ? await predication : predication) {
-          return { value, done: false }
+const FilteringAsyncIterator = (asyncIterator, predicate) => {
+  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 booleanResult = predicate(item)
+        buffer.append([booleanResult, item])
+      }
+      isAsyncIteratorDone = true
+    },
+
+    
+    async next() {
+      if (!consumingAsyncIterator) {
+        this._consumeAsyncIterator()
+        consumingAsyncIterator = true
+      }
+
+      while (!isAsyncIteratorDone) {
+        if (buffer.length > 0) {
+          let [booleanResult, item] = buffer.popFirst()
+          if (isPromise(booleanResult)) {
+            booleanResult = await booleanResult
+          }
+          if (booleanResult) {
+            return { value: item, done: false }
+          }
+          continue
         }
+        await sleep(10)
       }
-    }
-    return { value: undefined, done: true }
-  },
-})
+
+      while (buffer.length > 0) {
+        let [booleanResult, item] = buffer.popFirst()
+        if (isPromise(booleanResult)) {
+          booleanResult = await booleanResult
+        }
+        if (booleanResult) {
+          return { value: item, done: false }
+        }
+      }
+
+      return { value: undefined, done: true }
+    },
+
+  }
+}
 
 const arrayExtendMap = function (
   array, values, valuesMapper, valuesIndex,
@@ -1753,57 +1895,6 @@ const arrayReduce = function (array, reducer, result) {
   return result
 }
 
-// argument resolver for curry5
-const curry5ResolveArg0 = (
-  baseFunc, arg1, arg2, arg3, arg4,
-) => function arg0Resolver(arg0) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg1 = (
-  baseFunc, arg0, arg2, arg3, arg4,
-) => function arg1Resolver(arg1) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg2 = (
-  baseFunc, arg0, arg1, arg3, arg4,
-) => function arg2Resolver(arg2) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg3 = (
-  baseFunc, arg0, arg1, arg2, arg4,
-) => function arg3Resolver(arg3) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-// argument resolver for curry5
-const curry5ResolveArg4 = (
-  baseFunc, arg0, arg1, arg2, arg3,
-) => function arg3Resolver(arg4) {
-  return baseFunc(arg0, arg1, arg2, arg3, arg4)
-}
-
-const curry5 = function (baseFunc, arg0, arg1, arg2, arg3, arg4) {
-  if (arg0 == __) {
-    return curry5ResolveArg0(baseFunc, arg1, arg2, arg3, arg4)
-  }
-  if (arg1 == __) {
-    return curry5ResolveArg1(baseFunc, arg0, arg2, arg3, arg4)
-  }
-  if (arg2 == __) {
-    return curry5ResolveArg2(baseFunc, arg0, arg1, arg3, arg4)
-  }
-  if (arg3 == __) {
-    return curry5ResolveArg3(baseFunc, arg0, arg1, arg2, arg4)
-  }
-  return curry5ResolveArg4(baseFunc, arg0, arg1, arg2, arg3)
-}
-
 const objectKeys = Object.keys
 
 const objectReduceAsync = async function (object, reducer, result, keys, index) {
@@ -1938,8 +2029,6 @@ const reduce = function (...args) {
 
 const isBinary = ArrayBuffer.isView
 
-const add = (a, b) => a + b
-
 const _arrayExtend = function (array, values) {
   const arrayLength = array.length,
     valuesLength = values.length

package/every.js

@@ -42,27 +42,31 @@ const _every = function (collection, predicate) {
  * @synopsis
  * ```coffeescript [specscript]
  * type Foldable = Array|Set|Map|Generator|AsyncGenerator|{ reduce: function }|Object
- * type UnarySyncOrAsyncPredicate = any=>Promise|boolean
+ * type Predicate = any=>Promise|boolean
  *
- * predicate UnarySyncOrAsyncPredicate
+ * predicate Predicate
  *
  * every(foldable Foldable, predicate) -> result Promise|boolean
  * every(predicate)(foldable Foldable) -> result Promise|boolean
  * ```
  *
  * @description
- * Test a predicate concurrently across all elements of a foldable, returning true if all executions return true.
+ * Tests a predicate concurrently across all items of a foldable. Returns true if every item tests true by the predicate.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * console.log(
- *   every([1, 2, 3, 4, 5], isOdd),
- * ) // false
+ * {
+ *   const array = [1, 2, 3, 4, 5]
+ *   const isEveryNumberOdd = every(array, isOdd)
+ *   console.log(isEveryNumberOdd)
+ * }
  *
- * console.log(
- *   every([1, 3, 5], isOdd),
- * ) // true
+ * {
+ *   const array = [1, 3, 5]
+ *   const isEveryNumberOdd = every(array, isOdd)
+ *   console.log(isEveryNumberOdd)
+ * }
  * ```
  *
  * The following data types are considered to be foldables:
@@ -74,29 +78,19 @@ const _every = function (collection, predicate) {
  *  * `object with .reduce method`
  *  * `object`
  *
- * `every` works for async generators.
- *
- * ```javascript [playground]
- * const asyncNumbers = async function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * every(asyncNumbers(), async number => number < 6).then(console.log) // true
- * ```
- *
  * `every` supports a lazy interface for composability.
  *
  * ```javascript [playground]
  * pipe([1, 2, 3], [
  *   every(number => number < 5),
- *   console.log, // true
+ *   console.log,
  * ])
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * If the foldable is a promise, it is resolved for its value before further execution for the eager interface only.
  *
  * ```javascript [playground]
- * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log) // true
+ * every(Promise.resolve([1, 2, 3, 4, 5]), n => n < 6).then(console.log)
  * ```
  *
  * See also:

package/filter.js

@@ -92,18 +92,28 @@ const _filter = function (value, predicate) {
  * ```coffeescript [specscript]
  * type Filterable = Array|Set|Map|Generator|AsyncGenerator|{ filter: function }|Object
  *
- * type SyncOrAsyncPredicate = (
+ * type Predicate = (
  *   value any,
  *   indexOrKey number|string|any,
  *   filterable Filterable,
- * )=>(booleanResult Promise|boolean)
+ * )=>(booleanResult Promise|boolean|any)
  *
- * filter(filterable Promise|Filterable, predicate SyncOrAsyncPredicate) -> filteredFilterable Promise|Filterable
- * filter(predicate SyncOrAsyncPredicate)(filterable Filterable) -> filteredFilterable Promise|Filterable
+ * filter(filterable Promise|Filterable, predicate Predicate) -> filteredFilterable Promise|Filterable
+ * filter(predicate Predicate)(filterable Filterable) -> filteredFilterable Promise|Filterable
  * ```
  *
  * @description
- * Filters out items from a filterable, returning a filterable of the same type. The order of the items of the filterable is preserved.
+ * Filters out items from a filterable, returning a filtered filterable of the same type. The order of the items of the filterable is preserved.
+ *
+ * ```javascript [playground]
+ * const isOdd = number => number % 2 == 1
+ *
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * const filteredArray = filter(array, isOdd)
+ *
+ * console.log(filteredArray)
+ * ```
  *
  * The following data types are considered to be filterables:
  *  * `array`
@@ -114,11 +124,11 @@ 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 item from the filterable should be included in the returned filterable.
+ * The filtering operation is defined by the predicate function, which determines whether a given item from the filterable should be included in the filtered filterable.
  *
  * ```javascript
  * const predicate = function (item) {
- *   // booleanResult is the boolean result of the predicate test on item
+ *   // booleanResult is the boolean result of the predicate
  *   return booleanResult
  * }
  * ```
@@ -150,118 +160,71 @@ const _filter = function (value, predicate) {
  * 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(item any, key string, filterable Object) -> booleanResult Promise|boolean|any
  * ```
  *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const array = [1, 2, 3, 4, 5]
- *
- * const filteredArray = filter(array, isOdd)
+ * If the filterable is an object with a `.filter` method, the predicate function signature is defined externally.
  *
- * console.log(filteredArray)
- * ```
+ * If the filterable is a generator, the predicate function must be synchronous.
  *
- * If the predicate is asynchronous, it is executed concurrently.
+ * If the predicate function is asynchronous, it is executed concurrently.
  *
  * ```javascript [playground]
  * const asyncIsOdd = async number => number % 2 == 1
  *
  * const array = [1, 2, 3, 4, 5]
  *
- * const promise = filter(array, asyncIsOdd)
- * promise.then(console.log) // [1, 3, 5]
- * ```
- *
- * `filter` applies the predicate function to just the values of an object.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
- *
- * const obj = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ * const result = await filter(array, asyncIsOdd)
  *
- * const result = filter(obj, isOdd)
- * console.log(result) // { a: 1, c: 3, e: 5 }
+ * console.log(result)
  * ```
  *
- * `filter` applies the predicate to the values of the entries of a map.
+ * `filter` applies the predicate function to just the values of objects and maps.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const myMap = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
+ * const object = { a: 1, b: 2, c: 3, d: 4, e: 5 }
+ * const map = new Map([['a', 1], ['b', 2], ['c', 3], ['d', 4], ['e', 5]])
  *
- * const result = filter(myMap, isOdd)
- * console.log(result) // Map(3) { 'a' => 1, 'c' => 3, 'e' => 5 }
- * ```
- *
- * For generators, `filter` returns a lazily filtered generator. All values that are normally yielded by the generator that test false by the predicate are excluded from the returned generator.
- *
- * ```javascript [playground]
- * const isOdd = number => number % 2 == 1
+ * const filteredObject = filter(object, isOdd)
+ * const filteredMap = filter(map, isOdd)
  *
- * const numbersGeneratorFunction = function* () {
- *   yield 1; yield 2; yield 3; yield 4; yield 5
- * }
- *
- * const numbersGenerator = numbersGeneratorFunction()
- * const oddNumbersGenerator = filter(numbersGeneratorFunction(), isOdd)
- *
- * for (const number of numbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
- * }
- *
- * for (const number of oddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
- * }
+ * console.log(filteredObject)
+ * console.log(filteredMap)
  * ```
  *
- * For async generators, `filter` returns a lazily filtered async generator. All values that are normally yielded by the async generator that test falsy by the predicate are excluded from the returned async generator.
+ * For generators, `filter` returns a filtered generator.
  *
  * ```javascript [playground]
- * const asyncIsOdd = async number => number % 2 == 1
+ * const isOdd = number => number % 2 == 1
  *
- * const asyncNumbersGeneratorFunction = async function* () {
+ * const generateNumbers = function* () {
  *   yield 1; yield 2; yield 3; yield 4; yield 5
  * }
  *
- * const asyncNumbersGenerator = asyncNumbersGeneratorFunction()
- *
- * const asyncOddNumbersGenerator = filter(asyncNumbersGeneratorFunction(), asyncIsOdd)
+ * const numbers = generateNumbers()
+ * const oddNumbers = filter(generateNumbers(), isOdd)
  *
- * for await (const number of asyncNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 2
- *                       // 3
- *                       // 4
- *                       // 5
+ * console.log('numbers')
+ * for (const number of numbers) {
+ *   console.log(number)
  * }
  *
- * for await (const number of asyncOddNumbersGenerator) {
- *   console.log(number) // 1
- *                       // 3
- *                       // 5
+ * console.log('odd numbers')
+ * for (const number of oddNumbers) {
+ *   console.log(number)
  * }
  * ```
  *
- * Any promises passed in data argument position are resolved for their values before further execution.
+ * If the filterable is a promise, it is resolved for its value before further execution for the eager interface only. 
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
  * filter(Promise.resolve([1, 2, 3, 4, 5]), isOdd).then(console.log)
- * // [1, 3, 5]
  * ```
  *
  * See also:

package/flatMap.js

@@ -66,22 +66,30 @@ const _flatMap = function (value, flatMapper) {
  * ```coffeescript [specscript]
  * type Monad = Array|string|Set|Generator|AsyncGenerator|{ flatMap: string }|{ chain: string }|Object
  *
- * type SyncOrAsyncFlatMapper = (
+ * type FlatMapper = (
  *   item any,
  *   indexOrKey number|string|any,
  *   monad Monad
  * )=>(flatMappedItem Promise|Monad|any)
  *
- * flatMap(monad Promise|Monad, flatMapper SyncOrAsyncFlatMapper) -> flatMappedMonad Promise|Monad
- * flatMap(flatMapper SyncOrAsyncFlatMapper)(monad Monad) -> flatMappedMonad Promise|Monad
+ * flatMap(monad Promise|Monad, flatMapper FlatMapper) -> flatMappedMonad Promise|Monad
+ * flatMap(flatMapper FlatMapper)(monad Monad) -> flatMappedMonad Promise|Monad
  * ```
  *
  * @description
  * Applies a flat-mapper function to each item of a monad, returning a flat-mapped monad of the same type.
  *
- * A flat-mapping operation iterates through each item of a monad and applies the flat-mapper function to each item, flattening the result of the execution into the returned monad.
+ * ```javascript [playground]
+ * const duplicate = value => [value, value]
+ *
+ * const duplicated = flatMap([1, 2, 3, 4, 5], duplicate)
+ *
+ * console.log(duplicated)
+ * ```
+ *
+ * `flatMap` iterates through each item of a monad and applies the flat-mapper function to each item, concatenating the execution result (flat-mapped item) into the flat-mapped monad. If the execution result is a promise, it is resolved for its value before being concatenated into the flat-mapped monad. If the execution result is asynchronously iterable, it is muxed into the flat-mapped monad.
  *
- * If the flat-mapper is asynchronous, it is executed concurrently. The execution result may be asynchronously iterable, in which case it is muxed into the returned monad.
+ * If the flat-mapper function is asynchronous, it is executed concurrently.
  *
  * The following data types are considered to be monads:
  *  * `array`
@@ -125,15 +133,7 @@ const _flatMap = function (value, flatMapper) {
  * flatMapper(item any, key string, monad Object) -> flatMappedItem Promise|Monad|any
  * ```
  *
- * ```javascript [playground]
- * const duplicate = value => [value, value]
- *
- * const duplicated = flatMap([1, 2, 3, 4, 5], duplicate)
- *
- * console.log(duplicated)
- * ```
- *
- * If the iterable is an object with a `.flatMap` or `.chain` method, the flat-mapper function signature is defined externally.
+ * If the iterable is an object with a `flatMap` or `chain` method, the flat-mapper function signature is defined externally.
  *
  * Values from async generators are muxed. Muxing, or asynchronously "mixing", is the process of combining multiple asynchronous sources into one source, with order determined by the asynchronous resolution of the individual promise elements.
  *
@@ -153,7 +153,7 @@ const _flatMap = function (value, flatMapper) {
  * // values from async generators are muxed
  * const muxed = await flatMap(['foo', 'bar', 'baz'], asyncRepeat3)
  *
- * console.log(muxed)
+ * console.log('muxed:', muxed)
  *
  * const repeat3 = function* (message) {
  *   yield message; yield message; yield message
@@ -162,7 +162,7 @@ const _flatMap = function (value, flatMapper) {
  * // values from generators and other monads are concatenated
  * const repeated = flatMap(['foo', 'bar', 'baz'], repeat3)
  *
- * console.log(repeated)
+ * console.log('repeated:', repeated)
  * ```
  *
  * If the monad is a promise, it is resolved for its value before further execution for the eager interface only.