rubico 2.7.3 → 2.7.4

package/_internal/reducerMap.js

@@ -21,11 +21,11 @@ const curry2 = require('./curry2')
  */
 const reducerMap = (
   reducer, mapper,
-) => function mappingReducer(result, reducerItem) {
-  const mappingReducerItem = mapper(reducerItem)
-  return isPromise(mappingReducerItem)
-    ? mappingReducerItem.then(curry2(reducer, result, __))
-    : reducer(result, mappingReducerItem)
+) => function mappingReducer(result, reducerElement) {
+  const mappingReducerElement = mapper(reducerElement)
+  return isPromise(mappingReducerElement)
+    ? mappingReducerElement.then(curry2(reducer, result, __))
+    : reducer(result, mappingReducerElement)
 }
 
 module.exports = reducerMap

package/_internal/reducerSome.d.ts

@@ -6,11 +6,11 @@ export = reducerSome;
  * ```coffeescript [specscript]
  * reducerSome(
  *   predicate any=>boolean,
- * ) -> anyReducer (result boolean, item any)=>boolean
+ * ) -> anyReducer (result boolean, element any)=>boolean
  * ```
  *
  * @related foldableAllReducer
  *
  * @TODO throw to break early?
  */
-declare function reducerSome(predicate: any): (result: any, item: any) => any;
+declare function reducerSome(predicate: any): (result: any, element: any) => any;

package/_internal/reducerSome.js

@@ -10,17 +10,17 @@ const isPromise = require('./isPromise')
  * ```coffeescript [specscript]
  * reducerSome(
  *   predicate any=>boolean,
- * ) -> anyReducer (result boolean, item any)=>boolean
+ * ) -> anyReducer (result boolean, element any)=>boolean
  * ```
  *
  * @related foldableAllReducer
  *
  * @TODO throw to break early?
  */
-const reducerSome = predicate => function anyReducer(result, item) {
+const reducerSome = predicate => function anyReducer(result, element) {
   return result === true ? result
-    : isPromise(result) ? result.then(curry2(reducerAnySync(predicate), __, item))
-    : result ? true : predicate(item)
+    : isPromise(result) ? result.then(curry2(reducerAnySync(predicate), __, element))
+    : result ? true : predicate(element)
 }
 
 module.exports = reducerSome

package/_internal/reducerTryCatch.d.ts

@@ -4,7 +4,7 @@ export = reducerTryCatch;
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accum any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (accum any, element any)=>(nextAccumulator Promise|any)
  *
  * reducerTryCatch(
  *   reducer function,
@@ -12,4 +12,4 @@ export = reducerTryCatch;
  * ) -> errorHandlingReducer function
  * ```
  */
-declare function reducerTryCatch(reducer: any, transducerTryer: any, catcher: any): (accum: any, item: any) => any;
+declare function reducerTryCatch(reducer: any, transducerTryer: any, catcher: any): (accum: any, element: any) => any;

package/_internal/reducerTryCatch.js

@@ -12,14 +12,14 @@ const curry2 = require('./curry2')
  *   reducer function,
  *   error Error,
  *   accum any,
- *   item any,
+ *   element any,
  * ) -> Promise|any
  * ```
  */
 const _reducerTryCatchErrorHandler = function (
-  catcher, reducer, error, accum, item,
+  catcher, reducer, error, accum, element,
 ) {
-  const c = catcher(error, item)
+  const c = catcher(error, element)
   return isPromise(c) ? c.then(curry2(reducer, accum, __)) : reducer(accum, c)
 }
 
@@ -28,7 +28,7 @@ const _reducerTryCatchErrorHandler = function (
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (accum any, item any)=>(nextAccumulator Promise|any)
+ * type Reducer = (accum any, element any)=>(nextAccumulator Promise|any)
  *
  * reducerTryCatch(
  *   reducer function,
@@ -38,15 +38,15 @@ const _reducerTryCatchErrorHandler = function (
  */
 const reducerTryCatch = function (reducer, transducerTryer, catcher) {
   const finalReducer = transducerTryer(reducer)
-  return function errorHandlingReducer(accum, item) {
+  return function errorHandlingReducer(accum, element) {
     try {
-      const ret = finalReducer(accum, item)
+      const ret = finalReducer(accum, element)
       return isPromise(ret) ? ret.catch(curry5(
-        _reducerTryCatchErrorHandler, catcher, reducer, __, accum, item,
+        _reducerTryCatchErrorHandler, catcher, reducer, __, accum, element,
       )) : ret
     } catch (error) {
       return _reducerTryCatchErrorHandler(
-        catcher, reducer, error, accum, item,
+        catcher, reducer, error, accum, element,
       )
     }
   }

package/_internal/setFilter.d.ts

@@ -11,6 +11,6 @@ export = setFilter;
  * ```
  *
  * @description
- * Filter items of a Set concurrently by predicate. `predicate` may be asynchronous.
+ * Filter elements of a Set concurrently by predicate. `predicate` may be asynchronous.
  */
 declare function setFilter(value: any, predicate: any): any;

package/_internal/setFilter.js

@@ -19,19 +19,19 @@ const noop = require('./noop')
  * ```
  *
  * @description
- * Filter items of a Set concurrently by predicate. `predicate` may be asynchronous.
+ * Filter elements of a Set concurrently by predicate. `predicate` may be asynchronous.
  */
 const setFilter = function (value, predicate) {
   const result = new Set(),
     resultAdd = result.add.bind(result),
     promises = []
-  for (const item of value) {
-    const predication = predicate(item, item, value)
+  for (const element of value) {
+    const predication = predicate(element, element, value)
     if (isPromise(predication)) {
       promises.push(predication.then(curry3(
-        thunkConditional, __, thunkify1(resultAdd, item), noop)))
+        thunkConditional, __, thunkify1(resultAdd, element), noop)))
     } else if (predication) {
-      result.add(item)
+      result.add(element)
     }
   }
   return promises.length == 0

package/_internal/setFlatten.js

@@ -30,45 +30,45 @@ const setFlatten = function (set) {
   const size = set.size,
     promises = [],
     result = new Set(),
-    resultAddReducer = (_, subItem) => result.add(subItem),
+    resultAddReducer = (_, subElement) => result.add(subElement),
     resultAdd = curry3(callPropUnary, result, 'add', __),
     getResult = () => result
 
-  for (const item of set) {
-    if (isArray(item)) {
-      const itemLength = item.length
-      let itemIndex = -1
-      while (++itemIndex < itemLength) {
-        result.add(item[itemIndex])
+  for (const element of set) {
+    if (isArray(element)) {
+      const elementLength = element.length
+      let elementIndex = -1
+      while (++elementIndex < elementLength) {
+        result.add(element[elementIndex])
       }
-    } else if (item == null) {
-      result.add(item)
-    } else if (typeof item[symbolIterator] == 'function') {
-      for (const subItem of item) {
-        result.add(subItem)
+    } else if (element == null) {
+      result.add(element)
+    } else if (typeof element[symbolIterator] == 'function') {
+      for (const subElement of element) {
+        result.add(subElement)
       }
-    } else if (typeof item[symbolAsyncIterator] == 'function') {
+    } else if (typeof element[symbolAsyncIterator] == 'function') {
       promises.push(
-        asyncIteratorForEach(item[symbolAsyncIterator](), resultAdd))
-    } else if (typeof item.chain == 'function') {
-      const monadValue = item.chain(identity)
+        asyncIteratorForEach(element[symbolAsyncIterator](), resultAdd))
+    } else if (typeof element.chain == 'function') {
+      const monadValue = element.chain(identity)
       isPromise(monadValue)
         ? promises.push(monadValue.then(resultAdd))
         : result.add(monadValue)
-    } else if (typeof item.flatMap == 'function') {
-      const monadValue = item.flatMap(identity)
+    } else if (typeof element.flatMap == 'function') {
+      const monadValue = element.flatMap(identity)
       isPromise(monadValue)
         ? promises.push(monadValue.then(resultAdd))
         : result.add(monadValue)
-    } else if (typeof item.reduce == 'function') {
-      const folded = item.reduce(resultAddReducer, null)
+    } else if (typeof element.reduce == 'function') {
+      const folded = element.reduce(resultAddReducer, null)
       isPromise(folded) && promises.push(folded)
-    } else if (item.constructor == Object) {
-      for (const key in item) {
-        result.add(item[key])
+    } else if (element.constructor == Object) {
+      for (const key in element) {
+        result.add(element[key])
       }
     } else {
-      result.add(item)
+      result.add(element)
     }
   }
   return promises.length == 0 ? result : promiseAll(promises).then(getResult)

package/_internal/setMap.d.ts

@@ -12,6 +12,6 @@ export = setMap;
  * ```
  *
  * @description
- * Apply a mapper concurrently to each item of a set, returning a set of results.
+ * Apply a mapper concurrently to each element of a set, returning a set of results.
  */
 declare function setMap(set: any, mapper: any): any;

package/_internal/setMap.js

@@ -18,17 +18,17 @@ const callPropUnary = require('./callPropUnary')
  * ```
  *
  * @description
- * Apply a mapper concurrently to each item of a set, returning a set of results.
+ * Apply a mapper concurrently to each element of a set, returning a set of results.
  */
 const setMap = function (set, mapper) {
   const result = new Set(),
     promises = []
-  for (const item of set) {
-    const resultItem = mapper(item, item, set)
-    if (isPromise(resultItem)) {
-      promises.push(resultItem.then(curry3(callPropUnary, result, 'add', __)))
+  for (const element of set) {
+    const resultElement = mapper(element, element, set)
+    if (isPromise(resultElement)) {
+      promises.push(resultElement.then(curry3(callPropUnary, result, 'add', __)))
     } else {
-      result.add(resultItem)
+      result.add(resultElement)
     }
   }
   return promises.length == 0

package/_internal/setMapPool.js

@@ -26,15 +26,15 @@ const _setMapPoolAsync = async function (
     if (promises.size >= concurrency) {
       await promiseRace(promises)
     }
-    const resultItem = f(iteration.value, iteration.value, s)
-    if (isPromise(resultItem)) {
-      const selfDeletingPromise = resultItem.then(resolvedValue => {
+    const resultElement = f(iteration.value, iteration.value, s)
+    if (isPromise(resultElement)) {
+      const selfDeletingPromise = resultElement.then(resolvedValue => {
         promises.delete(selfDeletingPromise)
         result.add(resolvedValue)
       })
       promises.add(selfDeletingPromise)
     } else {
-      result.add(resultItem)
+      result.add(resultElement)
     }
     iteration = iterator.next()
   }
@@ -53,24 +53,24 @@ const _setMapPoolAsync = async function (
  * ```
  *
  * @description
- * Apply a function `f` with limited concurrency to each item of a set `s`, returning an array of results.
+ * Apply a function `f` with limited concurrency to each element of a set `s`, returning an array of results.
  */
 const setMapPool = function (s, concurrency, f) {
   const result = new Set()
   const iterator = s[symbolIterator]()
   let iteration = iterator.next()
   while (!iteration.done) {
-    const resultItem = f(iteration.value, iteration.value, s)
-    if (isPromise(resultItem)) {
+    const resultElement = f(iteration.value, iteration.value, s)
+    if (isPromise(resultElement)) {
       const promises = new Set()
-      const selfDeletingPromise = resultItem.then(resolvedValue => {
+      const selfDeletingPromise = resultElement.then(resolvedValue => {
         promises.delete(selfDeletingPromise)
         result.add(resolvedValue)
       })
       promises.add(selfDeletingPromise)
       return _setMapPoolAsync(s, iterator, concurrency, f, result, promises)
     }
-    result.add(resultItem)
+    result.add(resultElement)
     iteration = iterator.next()
   }
   return result

package/_internal/setMapSeries.js

@@ -14,11 +14,11 @@ const symbolIterator = require('./symbolIterator')
 const _setMapSeriesAsync = async function (iterator, f, result) {
   let iteration = iterator.next()
   while (!iteration.done) {
-    let resultItem = f(iteration.value)
-    if (isPromise(resultItem)) {
-      resultItem = await resultItem
+    let resultElement = f(iteration.value)
+    if (isPromise(resultElement)) {
+      resultElement = await resultElement
     }
-    result.add(resultItem)
+    result.add(resultElement)
     iteration = iterator.next()
   }
   return result
@@ -33,27 +33,27 @@ const _setMapSeriesAsync = async function (iterator, f, result) {
  *   value any,
  *   key any,
  *   collection Set
- * )=>(resultItem Promise|any)
+ * )=>(resultElement Promise|any)
  *
  * setMapSeries(set Set, f SetMapper) -> Promise|Set
  * ```
  *
  * @description
- * Apply a mapper in series to each value of a set, returning a new set of mapped items. Mapper may be asynchronous.
+ * Apply a mapper in series to each value of a set, returning a new set of mapped elements. Mapper may be asynchronous.
  */
 const setMapSeries = function (set, f) {
   const result = new Set()
   const iterator = set[symbolIterator]()
   let iteration = iterator.next()
   while (!iteration.done) {
-    const resultItem = f(iteration.value)
-    if (isPromise(resultItem)) {
-      return resultItem.then(funcConcat(
+    const resultElement = f(iteration.value)
+    if (isPromise(resultElement)) {
+      return resultElement.then(funcConcat(
         curry2(setAdd, result, __),
         thunkify3(_setMapSeriesAsync, iterator, f, result),
       ))
     }
-    result.add(resultItem)
+    result.add(resultElement)
     iteration = iterator.next()
   }
   return result

package/_internal/streamFlatExtend.js

@@ -26,49 +26,49 @@ const symbolAsyncIterator = require('./symbolAsyncIterator')
  *
  * streamFlatExtend<T>(
  *   stream Stream<T>,
- *   item <Monad<T>|Foldable<T>|T>
+ *   element <Monad<T>|Foldable<T>|T>
  * ) -> stream
  * ```
  */
-const streamFlatExtend = async function (stream, item) {
+const streamFlatExtend = async function (stream, element) {
   const resultStreamWrite = curry2(streamWrite, stream, __),
-    // resultStreamWriteReducer = (_, subItem) => stream.write(subItem),
+    // resultStreamWriteReducer = (_, subElement) => stream.write(subElement),
     resultStreamWriteReducer = funcConcatSync(getArg1, resultStreamWrite),
     promises = []
-  if (isArray(item)) {
-    const itemLength = item.length
-    let itemIndex = -1
-    while (++itemIndex < itemLength) {
-      stream.write(item[itemIndex])
+  if (isArray(element)) {
+    const elementLength = element.length
+    let elementIndex = -1
+    while (++elementIndex < elementLength) {
+      stream.write(element[elementIndex])
     }
-  } else if (item == null) {
-    stream.write(item)
-  } else if (typeof item[symbolIterator] == 'function') {
-    for (const subItem of item) {
-      stream.write(subItem)
+  } else if (element == null) {
+    stream.write(element)
+  } else if (typeof element[symbolIterator] == 'function') {
+    for (const subElement of element) {
+      stream.write(subElement)
     }
-  } else if (typeof item[symbolAsyncIterator] == 'function') {
+  } else if (typeof element[symbolAsyncIterator] == 'function') {
     promises.push(
-      asyncIteratorForEach(item[symbolAsyncIterator](), resultStreamWrite))
-  } else if (typeof item.chain == 'function') {
-    const monadValue = item.chain(identity)
+      asyncIteratorForEach(element[symbolAsyncIterator](), resultStreamWrite))
+  } else if (typeof element.chain == 'function') {
+    const monadValue = element.chain(identity)
     isPromise(monadValue)
       ? promises.push(monadValue.then(resultStreamWrite))
       : stream.write(monadValue)
-  } else if (typeof item.flatMap == 'function') {
-    const monadValue = item.flatMap(identity)
+  } else if (typeof element.flatMap == 'function') {
+    const monadValue = element.flatMap(identity)
     isPromise(monadValue)
       ? promises.push(monadValue.then(resultStreamWrite))
       : stream.write(monadValue)
-  } else if (typeof item.reduce == 'function') {
-    const folded = item.reduce(resultStreamWriteReducer, null)
+  } else if (typeof element.reduce == 'function') {
+    const folded = element.reduce(resultStreamWriteReducer, null)
     isPromise(folded) && promises.push(folded)
-  } else if (item.constructor == Object) {
-    for (const key in item) {
-      stream.write(item[key])
+  } else if (element.constructor == Object) {
+    for (const key in element) {
+      stream.write(element[key])
     }
   } else {
-    stream.write(item)
+    stream.write(element)
   }
   return promises.length == 0
     ? stream

package/_internal/streamFlatMap.js

@@ -24,8 +24,8 @@ const promiseAll = require('./promiseAll')
  */
 const streamFlatMap = async function (stream, flatMapper) {
   const promises = new Set()
-  for await (const item of stream) {
-    const monad = flatMapper(item)
+  for await (const element of stream) {
+    const monad = flatMapper(element)
     if (isPromise(monad)) {
       const selfDeletingPromise = monad.then(
         curry2(streamFlatExtend, stream, __)).then(

package/all.js

@@ -39,10 +39,10 @@ const _allValues = function (values) {
  * args Array<any>
  * argsOrPromises Array<Promise|any>
  *
- * type Resolver = (...args)=>Promise|any
+ * type SyncOrAsyncResolver = (...args)=>Promise|any
  *
- * arrayResolversOrPromisesOrValues Array<Resolver|Promise|any>
- * objectResolversOrPromisesOrValues Object<Resolver|Promise|any>
+ * arrayResolversOrPromisesOrValues Array<SyncOrAsyncResolver|Promise|any>
+ * objectResolversOrPromisesOrValues Object<SyncOrAsyncResolver|Promise|any>
  *
  * all(arrayValues Promise|Array<Promise|any>) -> arrayResult Promise|Array
  * all(...argsOrPromises, arrayResolversOrPromisesOrValues) -> arrayResult Promise|Array

package/and.js

@@ -99,7 +99,10 @@ const areAllPredicatesTruthy = 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>
  *
  * and(values Array<boolean|any>) -> result boolean
  * and(...argsOrPromises, predicatesOrValues) -> Promise|boolean
@@ -107,7 +110,7 @@ const areAllPredicatesTruthy = function (args, predicates) {
  * ```
  *
  * @description
- * Function equivalent to the [logical AND](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND) operator. Tests an array of predicate functions, promises, values, or a mix thereof.
+ * Function equivalent to the [Logical AND](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Logical_AND) operator. Tests an array of predicate functions, promises, values, or a mix thereof.
  *
  * If provided an array of boolean values, `and` returns true if all boolean values are true.
  *

package/assign.js

@@ -20,9 +20,9 @@ const _assign = function (object, funcs) {
  * ```coffeescript [specscript]
  * args Array<any>
  *
- * type Resolver = (...args)=>Promise|any
+ * type UnarySyncOrAsyncResolver = any=>Promise|any
  *
- * objectResolversOrPromisesOrValues Object<Resolver|Promise|any>
+ * objectResolversOrPromisesOrValues Object<UnarySyncOrAsyncResolver|Promise|any>
  *
  * assign(argumentObject Promise|Object, objectResolversOrPromisesOrValues) -> resultObject
  * assign(objectResolversOrPromisesOrValues)(argumentObject Object) -> resultObject

package/compose.js

@@ -10,17 +10,21 @@ const funcConcat = require('./_internal/funcConcat')
  *
  * @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>]
+ *
  * compose(funcs)(...args) -> result Promise|any
  * compose(...argsOrPromises, funcs) -> result Promise|any
  * compose(...funcs)(...args) -> result Promise|any
  * ```
  *
  * @description
- * Creates a function composition from multiple functions. Each function in the composition is evaluated starting from the last function in the composition in series, passing its return value as an argument to the previous function. The result of a composition execution is the return value of the first function in the composition. If any function in the composition is asynchronous, the result of the composition execution is a Promise.
+ * Creates a function composition from multiple functions. Each function in the composition is evaluated starting from the last function in the composition in series, passing its return value as an argument to the previous function. The result of a composition execution is the return value of the first function in the composition. All arguments provided to the composition are provided to the last function in the composition. If any function in the composition is asynchronous, the result of the composition execution is a Promise.
  *
  * ```javascript [playground]
  * const f = x => x * 2

package/curry.js

@@ -5,17 +5,14 @@ const curryArity = require('./_internal/curryArity')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type __ = Symbol(placeholder)
+ * __ Symbol(placeholder)
+ *
  * type ArgsWithPlaceholder = Array<__|any>
  *
  * args ArgsWithPlaceholder
  * moreArgs ArgsWithPlaceholder
  *
- * curry(
- *   func function,
- *   ...args
- * ) -> curriedFuncOrResult function|any
- *
+ * curry(func function, ...args) -> curriedFuncOrResult function|any
  * curriedFuncOrResult(...moreArgs) -> anotherCurriedFuncOrResult function|any
  * ```
  *
@@ -55,15 +52,11 @@ const curry = (func, ...args) => curryArity(func.length, func, args)
  * type __ = Symbol(placeholder)
  * type ArgsWithPlaceholder = Array<__|any>
  *
+ * n number
  * args ArgsWithPlaceholder
  * moreArgs ArgsWithPlaceholder
  *
- * curry.arity(
- *   arity number,
- *   func function,
- *   ...args
- * ) -> curriedFuncOrResult function|any
- *
+ * curry.arity(n number, func function, ...args) -> curriedFuncOrResult function|any
  * curriedFuncOrResult(...moreArgs) -> anotherCurriedFuncOrResult function|any
  * ```
  *