rubico 2.7.3 → 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,
  *   functor Functor
- * )=>(resultItem Promise|any)
+ * )=>(resultElement Promise|any)
  *
- * map(functor Promise|Functor, mapper Mapper) -> result Promise|Functor
- * map(mapper Mapper)(functor 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

@@ -22,17 +22,17 @@ const _not = function (args, predicate) {
  * args Array<any>
  * argsOrPromises Array<Promise|any>
  *
- * type Predicate = (...args)=>Promise|boolean
+ * type SyncOrAsyncPredicate = (...args)=>Promise|boolean
  *
- * predicate Predicate
+ * predicate SyncOrAsyncPredicate
  *
- * not(value boolean) -> negated boolean
+ * 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 }
@@ -46,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.

package/or.js

@@ -99,7 +99,10 @@ const areAnyPredicatesTruthy = function (args, predicates) {
  * ```coffeescript [specscript]
  * args Array<any>
  * argsOrPromises Array<Promise|any>
- * predicatesOrValues Array<function|boolean|any>
+ *
+ * type SyncOrAsyncPredicate = (...args)=>Promise|boolean|any
+ *
+ * predicatesOrValues Array<SyncOrAsyncPredicate|boolean|any>
  *
  * or(values Array<boolean|any>) -> result boolean
  * or(...argsOrPromises, predicatesOrValues) -> Promise|boolean
@@ -107,7 +110,7 @@ const areAnyPredicatesTruthy = function (args, predicates) {
  * ```
  *
  * @description
- * 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.
+ * 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.
  *

package/package.json

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

package/pipe.js

@@ -10,17 +10,21 @@ const __ = require('./_internal/placeholder')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * funcs Array<function>
  * args Array<any>
  * argsOrPromises Array<Promise|any>
  *
+ * type SyncOrAsyncFunction = (...args)=>Promise|any
+ * type UnarySyncOrAsyncFunction = any=>Promise|any
+ *
+ * funcs [SyncOrAsyncFunction, ...Array<UnarySyncOrAsyncFunction>]
+ *
  * pipe(funcs)(...args) -> result Promise|any
- * pipe(...argsOrPromises, funcs Array<function>) -> 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([
@@ -51,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]

package/reduce.d.ts

@@ -28,7 +28,7 @@ export = reduce;
  * ```
  *
  * @description
- * Transforms a collection based on a reducer function and optional initial value. In a reducing operation, the result is defined in the beginning as either the initial value if supplied or the first item of the collection. The reducing operation then iterates through the remaining items in the collection, executing the reducer at each iteration to return the result to be used in the next iteration. The final result is the result of the execution of the reducer at the last item of the iteration. `reduce` accepts the following collections:
+ * Transforms a collection based on a reducer function and optional initial value. In a reducing operation, the result is defined in the beginning as either the initial value if supplied or the first element of the collection. The reducing operation then iterates through the remaining elements in the collection, executing the reducer at each iteration to return the result to be used in the next iteration. The final result is the result of the execution of the reducer at the last element of the iteration. `reduce` accepts the following collections:
  *
  *  * `Array`
  *  * `Object`
@@ -37,7 +37,7 @@ export = reduce;
  *  * `Iterator`/`Generator`
  *  * `AsyncIterator`/`AsyncGenerator`
  *
- * For arrays (type `Array`), `reduce` executes the reducer function for each item of the array in order, returning a new result at each execution to be used in the next execution. On each iteration, the reducer is passed the accumulator, the item of the iteration, the index of the item in the array, and a reference to the original array.
+ * For arrays (type `Array`), `reduce` executes the reducer function for each element of the array in order, returning a new result at each execution to be used in the next execution. On each iteration, the reducer is passed the accumulator, the element of the iteration, the index of the element in the array, and a reference to the original array.
  *
  * ```javascript [playground]
  * const max = (a, b) => a > b ? a : b
@@ -51,7 +51,7 @@ export = reduce;
  * ) // 5
  * ```
  *
- * If an optional initial value is provided, the result starts as the provided initial value rather than the first item of the collection.
+ * If an optional initial value is provided, the result starts as the provided initial value rather than the first element of the collection.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -91,7 +91,7 @@ export = reduce;
  * ) // 15
  * ```
  *
- * For sets (type `Set`), `reduce` executes the reducer function for each item of the set. On each iteration, the reducer is passed the accumulator and item of the set.
+ * For sets (type `Set`), `reduce` executes the reducer function for each element of the set. On each iteration, the reducer is passed the accumulator and element of the set.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -107,7 +107,7 @@ export = reduce;
  * ) // 15
  * ```
  *
- * For maps (type `Map`), `reduce` executes the reducer function for each value of each entry of the map. On each iteration, the reducer is passed the accumulator, the map item, the key of the map item, and a reference to the original map.
+ * For maps (type `Map`), `reduce` executes the reducer function for each value of each entry of the map. On each iteration, the reducer is passed the accumulator, the map element, the key of the map element, and a reference to the original map.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -123,7 +123,7 @@ export = reduce;
  * ) // 15
  * ```
  *
- * For iterators (type `Iterator`) and generators (type `Generator`), `reduce` executes the reducer function for each value of the iterator/generator. On each iteration, the reducer is passed the accumulator and the item of the iteration. The iterator/generator is consumed in the process.
+ * For iterators (type `Iterator`) and generators (type `Generator`), `reduce` executes the reducer function for each value of the iterator/generator. On each iteration, the reducer is passed the accumulator and the element of the iteration. The iterator/generator is consumed in the process.
  *
  * ```javascript [playground]
  * const add = (a, b) => a + b
@@ -141,7 +141,7 @@ export = reduce;
  * ) // 15
  * ```
  *
- * For asyncIterators (type `AsyncIterator`) and asyncGenerators (type `AsyncGenerator`), `reduce` executes the reducer function for each value of the asyncIterator/asyncGenerator. On each iteration, the reducer is passed the accumulator and the item of the async iteration. The asyncIterator/asyncGenerator is consumed in the process.
+ * For asyncIterators (type `AsyncIterator`) and asyncGenerators (type `AsyncGenerator`), `reduce` executes the reducer function for each value of the asyncIterator/asyncGenerator. On each iteration, the reducer is passed the accumulator and the element of the async iteration. The asyncIterator/asyncGenerator is consumed in the process.
  *
  * ```javascript [playground]
  * const asyncAdd = async (a, b) => a + b