rubico 2.7.2 → 2.7.4

package/lt.js

@@ -6,20 +6,27 @@ const lessThan = require('./_internal/lessThan')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * lt(leftValue Promise|any, rightValue Promise|any) -> boolean
+ * args Array<any>
+ * argsOrPromises Array<Promise|any>
  *
- * lt(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * lt(...args, leftValue Promise|any, right function) -> Promise|boolean
+ * type SyncOrAsyncResolver = (...args)=>Promise|any
  *
- * lt(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * lt(...args, left function, rightValue Promise|any) -> Promise|boolean
+ * leftValue Promise|any
+ * rightValue Promise|any
+ * leftResolver SyncOrAsyncResolver
+ * rightResolver SyncOrAsyncResolver
  *
- * lt(left function, right function)(...args) -> Promise|boolean
- * lt(...args, left function, right function) -> Promise|boolean
+ * lt(leftValue, rightValue) -> Promise|boolean
+ * lt(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
+ * lt(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
+ * lt(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
+ * lt(leftResolver, rightValue)(...args) -> Promise|boolean
+ * lt(leftValue, rightResolver)(...args) -> Promise|boolean
+ * lt(leftResolver, rightResolver)(...args) -> Promise|boolean
  * ```
  *
  * @description
- * Test if a value is less than (`<`) another value.
+ * Functional equivalent of the [Less than (<)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than) operator. Tests if a value is less than (`<`) another value.
  *
  * ```javascript [playground]
  * console.log(lt(1, 3)) // true
@@ -27,7 +34,7 @@ const lessThan = require('./_internal/lessThan')
  * console.log(lt(4, 3)) // false
  * ```
  *
- * If either of the two values are resolver functions, `lt` returns a function that resolves the values to compare from its arguments.
+ * If either of the two values are resolver functions, `lt` returns a function that resolves the value(s) to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
@@ -39,6 +46,18 @@ const lessThan = require('./_internal/lessThan')
  * console.log(isLessThan3(5)) // false
  * ```
  *
+ * If either of the resolver functions is asynchronous, `lt` returns an asynchronous function.
+ *
+ * ```javascript [playground]
+ * const asyncIdentity = async value => value
+ *
+ * const asyncIsLessThan3 = lt(asyncIdentity, 3)
+ *
+ * asyncIsLessThan3(1).then(console.log) // true
+ * asyncIsLessThan3(3).then(console.log) // false
+ * asyncIsLessThan3(5).then(console.log) // false
+ * ```
+ *
  * `lt` supports a lazy API for composability.
  *
  * ```javascript [playground]

package/lte.js

@@ -6,20 +6,27 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * lte(leftValue Promise|any, rightValue Promise|any) -> boolean
- *
- * lte(leftValue Promise|any, right function)(...args) -> Promise|boolean
- * lte(...args, leftValue Promise|any, right function) -> Promise|boolean
- *
- * lte(left function, rightValue Promise|any)(...args) -> Promise|boolean
- * lte(...args, left function, rightValue Promise|any) -> Promise|boolean
- *
- * lte(left function, right function)(...args) -> Promise|boolean
- * lte(...args, left function, right function) -> Promise|boolean
+ * args Array<any>
+ * argsOrPromises Array<Promise|any>
+ *
+ * type SyncOrAsyncResolver = (...args)=>Promise|any
+ *
+ * leftValue Promise|any
+ * rightValue Promise|any
+ * leftResolver SyncOrAsyncResolver
+ * rightResolver SyncOrAsyncResolver
+ *
+ * lte(leftValue, rightValue) -> Promise|boolean
+ * lte(...argsOrPromises, leftResolver, rightValue) -> Promise|boolean
+ * lte(...argsOrPromises, leftValue, rightResolver) -> Promise|boolean
+ * lte(...argsOrPromises, leftResolver, rightResolver) -> Promise|boolean
+ * lte(leftResolver, rightValue)(...args) -> Promise|boolean
+ * lte(leftValue, rightResolver)(...args) -> Promise|boolean
+ * lte(leftResolver, rightResolver)(...args) -> Promise|boolean
  * ```
  *
  * @description
- * Test if a value is less than or equal (`<=`) to another value.
+ * Functional equivalent of the [Less than or equal (>=)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Less_than_or_equal) operator. Tests if a value is less than or equal (`<=`) to another value.
  *
  * ```javascript [playground]
  * console.log(lte(1, 3)) // true
@@ -27,16 +34,28 @@ const lessThanOrEqual = require('./_internal/lessThanOrEqual')
  * console.log(lte(4, 3)) // false
  * ```
  *
- * If either of the two values are resolver functions, `lte` returns a function that resolves the values to compare from its arguments.
+ * If either of the two values are resolver functions, `lte` returns a function that resolves the value(s) to compare.
  *
  * ```javascript [playground]
  * const identity = value => value
  *
  * const isLessThanOrEqualTo3 = lte(identity, 3)
  *
- * console.log(isLessThanOrEqualTo3(1), true)
- * console.log(isLessThanOrEqualTo3(3), true)
- * console.log(isLessThanOrEqualTo3(5), false)
+ * console.log(isLessThanOrEqualTo3(1)) // true
+ * console.log(isLessThanOrEqualTo3(3)) // true
+ * console.log(isLessThanOrEqualTo3(5)) // false
+ * ```
+ *
+ * If either of the two resolver functions is asynchronous, `lte` returns an asynchronous function.
+ *
+ * ```javascript [playground]
+ * const asyncIdentity = async value => value
+ *
+ * const asyncIsLessThanOrEqualTo3 = lte(asyncIdentity, 3)
+ *
+ * asyncIsLessThanOrEqualTo3(1).then(console.log) // true
+ * asyncIsLessThanOrEqualTo3(3).then(console.log) // true
+ * asyncIsLessThanOrEqualTo3(5).then(console.log) // false
  * ```
  *
  * `lte` supports a lazy API for composability.

package/map.d.ts

@@ -10,14 +10,14 @@ export = map;
  *   value any,
  *   indexOrKey number|string,
  *   collection Mappable
- * )=>(mappedItem Promise|any)
+ * )=>(mappedElement Promise|any)
  *
  * map(value Mappable, mapper Mapper) -> result Promise|Mappable
  * map(mapper Mapper)(value Mappable) -> result Promise|Mappable
  * ```
  *
  * @description
- * Applies a synchronous or asynchronous mapper function concurrently to each item of a collection, returning the results in a new collection of the same type. If order is implied by the collection, it is maintained in the result. `map` accepts the following collections:
+ * Applies a synchronous or asynchronous mapper function concurrently to each element of a collection, returning the results in a new collection of the same type. If order is implied by the collection, it is maintained in the result. `map` accepts the following collections:
  *
  *  * `Array`
  *  * `Object`
@@ -26,7 +26,7 @@ export = map;
  *  * `Iterator`/`Generator`
  *  * `AsyncIterator`/`AsyncGenerator`
  *
- * With arrays (type `Array`), `map` applies the mapper function to each item of the array, returning the transformed results in a new array ordered the same as the original array.
+ * With arrays (type `Array`), `map` applies the mapper function to each element of the array, returning the transformed results in a new array ordered the same as the original array.
  *
  * ```javascript [playground]
  * const square = number => number ** 2

package/map.js

@@ -95,18 +95,18 @@ const _map = function (value, f) {
  * ```coffeescript [specscript]
  * type Functor = Array|Set|Map|Generator|AsyncGenerator|{ map: function }|Object
  *
- * type Mapper = (
- *   item any,
+ * type SyncOrAsyncMapper = (
+ *   element any,
  *   indexOrKey number|string|any,
- *   ftor Functor
- * )=>(resultItem Promise|any)
+ *   functor Functor
+ * )=>(resultElement Promise|any)
  *
- * map(ftor Promise|Functor, mapper Mapper) -> result Promise|Functor
- * map(mapper Mapper)(ftor Functor) -> result Promise|Functor
+ * map(functor Promise|Functor, mapper SyncOrAsyncMapper) -> result Promise|Functor
+ * map(mapper SyncOrAsyncMapper)(functor Functor) -> result Promise|Functor
  * ```
  *
  * @description
- * Applies a mapper function to each item of a functor, returning a functor of the same type with the mapped items. The order of the items is maintained.
+ * Applies a mapper function to each element of a functor, returning a functor of the same type with the mapped elements. The order of the elements is maintained.
  *
  * The following data types are considered to be functors:
  *  * `array`
@@ -117,12 +117,12 @@ const _map = function (value, f) {
  *  * `object with .map method`
  *  * `object`
  *
- * The mapper function defines a mapping between a given item in the functor to a resulting item in the returned functor.
+ * The mapper function defines a mapping between a given element in the functor to a resulting element in the returned functor.
  *
  * ```javascript
- * const mapper = function (item) {
- *   // resultItem is the result of a mapping from item
- *   return resultItem
+ * const mapper = function (element) {
+ *   // resultElement is the result of a mapping from element
+ *   return resultElement
  * }
  * ```
  *
@@ -130,34 +130,34 @@ const _map = function (value, f) {
  *
  * If the functor is an array:
  * ```coffeescript [specscript]
- * mapper(item any, index number, ftor Array) -> resultItem Promise|any
+ * mapper(element any, index number, ftor Array) -> resultElement Promise|any
  * ```
  *
  * If the functor is a set:
  * ```coffeescript [specscript]
- * mapper(item any, item any, ftor Set) -> resultItem Promise|any
+ * mapper(element any, element any, ftor Set) -> resultElement Promise|any
  * ```
  *
  * If the functor is a map:
  * ```coffeescript [specscript]
- * mapper(item any, key any, ftor Map) -> resultItem Promise|any
+ * mapper(element any, key any, ftor Map) -> resultElement Promise|any
  * ```
  *
  * If the functor is a generator:
  * ```coffeescript [specscript]
- * mapper(item any) -> resultItem Promise|any
+ * mapper(element any) -> resultElement Promise|any
  * ```
  *
  * If the functor is an async generator:
  * ```coffeescript [specscript]
- * mapper(item any) -> resultItem Promise|any
+ * mapper(element any) -> resultElement Promise|any
  * ```
  *
  * If the functor is an object with a `.map` method, the mapper function signature is defined externally.
  *
  * If the functor is a plain object:
  * ```coffeescript [specscript]
- * mapper(item any, key string, ftor Object) -> resultItem Promise|any
+ * mapper(element any, key string, ftor Object) -> resultElement Promise|any
  * ```
  *
  * `map` works for arrays.
@@ -204,7 +204,7 @@ const _map = function (value, f) {
  * console.log(result) // Map { 'a' => 1, 'b' => 4, 'c' => 9, 'd' => 16, 'e' => 25 }
  * ```
  *
- * `map` applies the mapper function lazily to each value of a generator, creating a new generator with mapped items.
+ * `map` applies the mapper function lazily to each value of a generator, creating a new generator with mapped elements.
  *
  * ```javascript [playground]
  * const capitalize = string => string.toUpperCase()
@@ -221,7 +221,7 @@ const _map = function (value, f) {
  * console.log([...ABCGenerator]) // ['A', 'B', 'C']
  * ```
  *
- * `map` applies the mapper function lazily to each value of an async generator, creating a new async generator with mapped items.
+ * `map` applies the mapper function lazily to each value of an async generator, creating a new async generator with mapped elements.
  *
  * ```javascript [playground]
  * const capitalize = string => string.toUpperCase()
@@ -306,7 +306,7 @@ const _mapEntries = (value, f) => {
  *
  * type EntryMapper = (
  *   entry [key string|any, value any],
- * )=>(resultEntry Promise|[resultKey string|any, resultItem any])
+ * )=>(resultEntry Promise|[resultKey string|any, resultElement any])
  *
  * map.entries(
  *   value Promise|FunctorWithEntries,
@@ -398,13 +398,13 @@ map.entries = function mapEntries(arg0, arg1) {
  * ```coffeescript [specscript]
  * type Functor = Array|Object|Set|Map
  *
- * type Mapper = (
+ * type SyncOrAsyncMapper = (
  *   value any,
  *   indexOrKey number|string|any,
  *   f Functor
- * )=>(mappedItem Promise|any)
+ * )=>(mappedElement Promise|any)
  *
- * _mapSeries(f Functor, f Mapper) -> result Promise|Functor
+ * _mapSeries(f Functor, f SyncOrAsyncMapper) -> result Promise|Functor
  * ```
  */
 const _mapSeries = function (collection, f) {
@@ -437,18 +437,18 @@ const _mapSeries = function (collection, f) {
  * ```coffeescript [specscript]
  * type MapSeriesFunctor = Array|Object|Set|Map
  *
- * type Mapper = (
+ * type SyncOrAsyncMapper = (
  *   value any,
  *   indexOrKey number|string|any,
  *   ftor MapSeriesFunctor,
- * )=>(mappedItem Promise|any)
+ * )=>(mappedElement Promise|any)
  *
  * map.series(
  *   ftor Promise|MapSeriesFunctor,
- *   mapper Mapper
+ *   mapper SyncOrAsyncMapper
  * ) -> result MapSeriesFunctor
  *
- * map.series(mapper Mapper)(ftor MapSeriesFunctor)
+ * map.series(mapper SyncOrAsyncMapper)(ftor MapSeriesFunctor)
  *   -> result MapSeriesFunctor
  * ```
  *
@@ -537,21 +537,21 @@ const _mapPool = function (f, concurrency, mapper) {
  * ```coffeescript [specscript]
  * type MapPoolFunctor = Array|Object|Set|Map
  *
- * type Mapper = (
- *   item any,
+ * type SyncOrAsyncMapper = (
+ *   element any,
  *   indexOrKey number|string|any,
  *   ftor Functor
- * )=>(resultItem Promise|any)
+ * )=>(resultElement Promise|any)
  *
  * map.pool(
  *   ftor MapPoolFunctor,
  *   concurrency number,
- *   mapper Mapper
+ *   mapper SyncOrAsyncMapper
  * ) -> result Promise|Array
  *
  * map.pool(
  *   concurrency number,
- *   mapper Mapper
+ *   mapper SyncOrAsyncMapper
  * )(ftor MapPoolFunctor) -> result Promise|Array
  * ```
  *

package/monad/Mux.benchmark.js

@@ -16,7 +16,7 @@ const nested = [[1], 2, [[3]]]
 
 const muxConcatFlatten = arr => {
   const y = []
-  for (const item of muxConcat(arr)) y.push(item)
+  for (const element of muxConcat(arr)) y.push(element)
   return y
 }
 

package/monad/Mux.js

@@ -240,13 +240,13 @@ const muxZipAsync = async function*(x) {
  * Create rows from disparate Sequences
  *
  * @description
- * Mux.zip takes a Sequence of items or Sequences of items and outputs either an Iterator or an AsyncIterator that yields an Array of items of each supplied Sequence for a given iteration. If any Sequence supplied to Mux.zip is AsyncIterable or an AsyncGeneratorFunction, Mux.zip outputs an AsyncIterator. The Iterator or AsyncIterator will iterate as long as the longest iterator of the supplied Sequences; shorter iterators will yield undefined until the longest iterator is consumed.
+ * Mux.zip takes a Sequence of elements or Sequences of elements and outputs either an Iterator or an AsyncIterator that yields an Array of elements of each supplied Sequence for a given iteration. If any Sequence supplied to Mux.zip is AsyncIterable or an AsyncGeneratorFunction, Mux.zip outputs an AsyncIterator. The Iterator or AsyncIterator will iterate as long as the longest iterator of the supplied Sequences; shorter iterators will yield undefined until the longest iterator is consumed.
  *
  * @example
  * const iterator = Mux.zip([[1, 2, 3], ['a', 'b', 'c']])
  *
- * for (const item of iterator) {
- *   console.log(item) // [1, 'a']
+ * for (const element of iterator) {
+ *   console.log(element) // [1, 'a']
  *                     // [2, 'b']
  *                     // [3, 'c']
  * }
@@ -307,7 +307,7 @@ const muxConcatAsync = async function*(x) {
  * Concatenate Sequences into one
  *
  * @description
- * Mux.concat takes a Sequence of items or Sequences of items and outputs either an Iterator or an AsyncIterator that yields each item individually. The first of these items is the first item of the first Sequence, the next is the second item of the first Sequence, and so on until all Sequences have been iterated in order. Non-Sequence Items in the top-level Sequence are yielded as they are.
+ * Mux.concat takes a Sequence of elements or Sequences of elements and outputs either an Iterator or an AsyncIterator that yields each element individually. The first of these elements is the first element of the first Sequence, the next is the second element of the first Sequence, and so on until all Sequences have been iterated in order. Non-Sequence Elements in the top-level Sequence are yielded as they are.
  *
  * @example
  * const iter = Mux.concat([
@@ -396,7 +396,7 @@ const muxSwitchAsync = async function*(x) {
  * Interleave Sequences into one
  *
  * @description
- * Mux.switch takes a Sequence of items or Sequences of items and outputs either an Iterator or an AsyncIterator that yields each item individually. The first of these items is the first item of the first Sequence, the next is the first item of the second Sequence, and so on until all Sequences have yielded their first item. Then, the first Sequence yields its second item, the second Sequence yields its second item, and so on until all Sequences have finished iterating. Non-Sequence Items in the top-level Sequence are yielded as they are. When a shorter Sequence finishes iterating, the remaining Sequences will switch yielding amongst themselves.
+ * Mux.switch takes a Sequence of elements or Sequences of elements and outputs either an Iterator or an AsyncIterator that yields each element individually. The first of these elements is the first element of the first Sequence, the next is the first element of the second Sequence, and so on until all Sequences have yielded their first element. Then, the first Sequence yields its second element, the second Sequence yields its second element, and so on until all Sequences have finished iterating. Non-Sequence Elements in the top-level Sequence are yielded as they are. When a shorter Sequence finishes iterating, the remaining Sequences will switch yielding amongst themselves.
  *
  * @example
  * const iter = Mux.switch([
@@ -457,7 +457,7 @@ const muxRaceAsync = async function*(x) {
  * Asynchronously Race Sequences into one
  *
  * @description
- * Mux.race takes a Sequence of items or Sequences of items and outputs either an Iterator or an AsyncIterator that yields each item individually. The first of these items are the synchronous items of the top level Sequence, followed by the asynchronous items of any asynchronous sub Sequences. If any sub Sequences are asynchronous, the order of these asynchronous items in the final returned AsyncIterator is determined by the serial asynchronous resolution of the individual asynchronous sub Sequences. If all Sequences are synchronous, Mux.race behaves just as Mux.concat.
+ * Mux.race takes a Sequence of elements or Sequences of elements and outputs either an Iterator or an AsyncIterator that yields each element individually. The first of these elements are the synchronous elements of the top level Sequence, followed by the asynchronous elements of any asynchronous sub Sequences. If any sub Sequences are asynchronous, the order of these asynchronous elements in the final returned AsyncIterator is determined by the serial asynchronous resolution of the individual asynchronous sub Sequences. If all Sequences are synchronous, Mux.race behaves just as Mux.concat.
  *
  * @example
  * const f = async function*() { await delay(5); yield 10; yield 20 }

package/monad/Struct.js

@@ -106,7 +106,7 @@ Struct.values = x => isObject(x) ? objectValuesGenerator(x) : x.values()
  * <A any, B any>Struct.get(x Map<A, B>, index A) -> B|undefined
  *
  * @catchphrase
- * Get an item by index
+ * Get an element by index
  */
 Struct.get = (x, index) => {
   if (typeof x.get == 'function') return x.get(index)
@@ -179,7 +179,7 @@ Struct.size.objectKeys = x => {
  */
 const copySet = x => {
   const y = new Set()
-  for (const item of x) y.add(item)
+  for (const element of x) y.add(element)
   return y
 }
 

package/not.js

@@ -19,15 +19,20 @@ const _not = function (args, predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * not(value boolean) -> negated boolean
+ * args Array<any>
+ * argsOrPromises Array<Promise|any>
  *
- * not(...args, predicate function) -> negated boolean
+ * type SyncOrAsyncPredicate = (...args)=>Promise|boolean
  *
- * not(predicate function)(...args) -> negated boolean
+ * predicate SyncOrAsyncPredicate
+ *
+ * not(value Promise|boolean|any) -> negated Promise|boolean
+ * not(...argsOrPromises, predicate) -> negated Promise|boolean
+ * not(predicate)(...args) -> negated Promise|boolean
  * ```
  *
  * @description
- * Negate a value like the [logical NOT (`!`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) operator.
+ * Function equivalent to the [Logical NOT (`!`)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_NOT) operator. Negates a value.
  *
  * ```javascript [playground]
  * const myObj = { a: 1 }
@@ -41,9 +46,17 @@ const _not = function (args, predicate) {
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * console.log(
- *   not(isOdd)(3),
- * ) // false
+ * const isNotOdd = not(isOdd)
+ *
+ * console.log(isNotOdd(3)) // false
+ * ```
+ *
+ * `not` negates the resolved value of a promise.
+ *
+ * ```javascript [playground]
+ * const promise = Promise.resolve(false)
+ *
+ * not(promise).then(console.log) // true
  * ```
  *
  * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
@@ -73,7 +86,9 @@ const not = function (...args) {
     }
     return _not(args, predicateOrValue)
   }
-  return !predicateOrValue
+  return isPromise(predicateOrValue)
+    ? predicateOrValue.then(negate)
+    : !predicateOrValue
 }
 
 module.exports = not

package/omit.js

@@ -20,9 +20,8 @@ const _omit = function (source, paths) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * omit(paths Array<string>)(source Object) -> omitted Object
- *
- * omit(source Object, paths Array<string>) -> omitted Object
+ * omit(source Promise|Object, paths Array<string>) -> result Object
+ * omit(paths Array<string>)(source Object) -> result Object
  * ```
  *
  * @description

package/or.js

@@ -97,36 +97,52 @@ const areAnyPredicatesTruthy = function (args, predicates) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * or(values Array<boolean>) -> result boolean
+ * args Array<any>
+ * argsOrPromises Array<Promise|any>
  *
- * or(...args, predicatesOrValues Array<function|boolean>) -> Promise|boolean
+ * type SyncOrAsyncPredicate = (...args)=>Promise|boolean|any
  *
- * or(predicatesOrValues Array<function|boolean>)(...args) -> Promise|boolean
+ * predicatesOrValues Array<SyncOrAsyncPredicate|boolean|any>
+ *
+ * or(values Array<boolean|any>) -> result boolean
+ * or(...argsOrPromises, predicatesOrValues) -> Promise|boolean
+ * or(predicatesOrValues)(...args) -> Promise|boolean
  * ```
  *
  * @description
- * Tests an array of boolean values, returning true if any boolean values are truthy.
+ * Function equivalent to the [Logical OR](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_OR) operator. Tests arrays of predicate functions, promises, values, or a mix thereof.
+ *
+ * If provided an array of boolean values, `or` returns true if any boolean values are truthy.
  *
  * ```javascript [playground]
  * const oneIsLessThanZero = 1 < 0
  * const oneIsGreaterThanTwo = 1 > 2
  * const threeIsNotEqualToThree = 3 !== 3
  *
- * console.log(
- *   or([oneIsLessThanZero, oneIsGreaterThanTwo, threeIsNotEqualToThree]),
- * ) // false
+ * const condition = or([
+ *   oneIsLessThanZero,
+ *   oneIsGreaterThanTwo,
+ *   threeIsNotEqualToThree
+ * ])
+ * console.log(condition) // false
  * ```
  *
- * If any values in the array are synchronous or asynchronous predicate functions, `or` takes another argument to test concurrently against the predicate functions, returning true if any array values or resolved values from the predicates are truthy.
+ * If any predicate functions are provided in the array, `or` returns an aggregate predicate function that returns true for a given set of arguments if any provided predicate functions test true. If any provided predicate functions are asynchronous, the aggregate predicate function becomes asynchronous.
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
- *
- * const isEven = number => number % 2 == 0
- *
- * console.log(
- *   or([isOdd, isEven])(0),
- * ) // true
+ * const isNegative = number => number < 0
+ * const asyncIsGreaterThan3 = async number => number > 3
+ *
+ * const aggregatePredicate = or([
+ *   false,
+ *   isOdd,
+ *   isNegative,
+ *   asyncIsGreaterThan3,
+ * ])
+ *
+ * const condition = await aggregatePredicate(2)
+ * console.log(condition) // false
  * ```
  *
  * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rubico",
-  "version": "2.7.2",
+  "version": "2.7.4",
   "description": "[a]synchronous functional programming",
   "author": "Richard Tong",
   "license": "MIT",

package/pick.js

@@ -27,9 +27,8 @@ const _pick = function (source, keys) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * pick(object Object, keys Array<string>) -> result Object
- *
- * pick(keys Array<string>)(object Object) -> result Object
+ * pick(source Promise|Object, keys Array<string>) -> result Object
+ * pick(keys Array<string>)(source Object) -> result Object
  * ```
  *
  * @description

package/pipe.js

@@ -10,19 +10,21 @@ const __ = require('./_internal/placeholder')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * funcs Array<function>
  * args Array<any>
- * argsWithPromises Array<Promise|any>
+ * argsOrPromises Array<Promise|any>
  *
- * pipe(funcs)(...args) -> result Promise|any
+ * type SyncOrAsyncFunction = (...args)=>Promise|any
+ * type UnarySyncOrAsyncFunction = any=>Promise|any
  *
- * pipe(...argsWithPromises, funcs Array<function>) -> result Promise|any
+ * funcs [SyncOrAsyncFunction, ...Array<UnarySyncOrAsyncFunction>]
  *
+ * pipe(funcs)(...args) -> result Promise|any
+ * pipe(...argsOrPromises, funcs) -> result Promise|any
  * pipe(...funcs)(...args) -> result Promise|any
  * ```
  *
  * @description
- * Creates a function pipeline from multiple functions. Each function in the pipeline is evaluated in series, passing its return value as an argument to the next function. The result of a pipeline execution is the return value of the last function in the pipeline. If any function in the pipeline is asynchronous, the result of the pipeline execution is a Promise.
+ * Creates a function pipeline from multiple functions. Each function in the pipeline is evaluated in series, passing its return value as an argument to the next function. The result of a pipeline execution is the return value of the last function in the pipeline. All arguments provided to the pipeline are provided to the first function in the pipeline. If any function in the pipeline is asynchronous, the result of the pipeline execution is a Promise.
  *
  * ```javascript [playground]
  * const syncAdd123 = pipe([
@@ -53,16 +55,6 @@ const __ = require('./_internal/placeholder')
  * console.log(appendBC('a')) // 'abc'
  * ```
  *
- * When passed any amount of arguments before the array of functions, `pipe` executes eagerly; the array of functions is immediately invoked with the supplied arguments.
- *
- * ```javascript [playground]
- * pipe(1, 2, 3, [
- *   Array.of,
- *   map(number => number * 3),
- *   console.log, // [3, 6, 9]
- * ])
- * ```
- *
  * Any promises passed in argument position are resolved for their values before further execution. This only applies to the eager version of the API.
  *
  * ```javascript [playground]