rubico 2.7.2 → 2.7.4

package/README.md

@@ -26,7 +26,9 @@ pipe(numbers, [
 ```
 
 # Installation
-[Core build](https://unpkg.com/rubico/index.js) ([~9.8 kB minified and gzipped](https://unpkg.com/rubico/dist/rubico.min.js))
+[Core build](https://unpkg.com/rubico/index.js) ([~7.7 kB minified and gzipped](https://unpkg.com/rubico/dist/rubico.min.js))
+
+[Transducer module](https://unpkg.com/rubico/dist/Transducer.js) ([~1.5kb minified and gzipped](https://unpkg.com/rubico/dist/Transducer.min.js))
 
 with `npm`
 ```bash
@@ -86,7 +88,7 @@ When you import this library, you obtain the freedom that comes from having thos
 
 # Introduction
 
-rubico is a library for async-enabled functional programming in JavaScript. The library supports a simple and composable functional style in asynchronous environments.
+rubico is a library for [A]synchronous Functional Programming in JavaScript. The library supports a simple and composable functional style in asynchronous environments.
 
 ```javascript
 const {
@@ -119,7 +121,7 @@ const {
 } = rubico
 ```
 
-With async-enabled, or [a]synchronous, functional programming, functions provided to the rubico operators may be asynchronous and return a Promise. Any promises in argument position are also resolved before continuing with the operation.
+With [A]synchronous Functional Programming, any function may be asynchronous and return a promise. All promises are resolved for their values before continuing with the operation.
 
 ```javascript [playground]
 const helloPromise = Promise.resolve('hello')
@@ -133,7 +135,7 @@ pipe(helloPromise, [ // helloPromise is resolved for 'hello'
 ])
 ```
 
-All rubico operators support both an eager and a lazy API. The eager API takes all required arguments and executes at once, while its lazy API takes only the non-data arguments and executes lazily, returning a function that expects the data arguments. This dual API supports a natural and composable code style.
+All rubico operators support both eager and lazy APIs. The eager API takes all required arguments and executes at once, while the lazy API takes only the setup arguments and returns a function that executes later. This dual API supports a natural and composable code style.
 
 ```javascript [playground]
 const myObj = { a: 1, b: 2, c: 3 }
@@ -203,7 +205,7 @@ pipe(todoIDs, [
 ])
 ```
 
-rubico offers transducers in its `Transducer` module. You can consume these transducers with the `transform` and `compose` operators. You should use `compose` over `pipe` to chain a left-to-right composition of transducers.
+rubico offers transducers through its `Transducer` module. You can consume these transducers with rubico's `transform` and `compose` operators. You can use `compose` to chain a left-to-right composition of transducers.
 
 ```javascript [playground]
 const isOdd = number => number % 2 == 1
@@ -219,18 +221,18 @@ const generateNumbers = function* () {
 }
 
 pipe(generateNumbers(), [
-  transform(compose([
+  transform(compose(
     Transducer.filter(isOdd),
     Transducer.map(asyncSquare),
-  ]), []),
+  ), []),
   console.log, // [1, 9, 25]
 ])
 ```
 
-For advanced asynchronous use cases, some of the operators have property functions that have different asynchronous behavior, e.g.
- * `map` - apply a mapper function concurrently
- * `map.pool` - apply a mapper function concurrently with a concurrency limit
- * `map.series` - apply a mapper function serially
+For advanced asynchronous use cases, some of the rubico operators have property functions that have various asynchronous behavior, e.g.
+ * `map` - applies a mapper function concurrently
+ * `map.pool` - applies a mapper function concurrently with a concurrency limit
+ * `map.series` - applies a mapper function serially
 
 For more functions beyond the core operators, please visit `rubico/x`. You can find the full documentation at [rubico.land/docs](https://rubico.land/docs).
 
@@ -241,7 +243,7 @@ npm run bench
 ```
 
 # Contributing
-Your feedback and contributions are welcome. If you have a suggestion, please raise an issue. Prior to that, please search through the issues first in case your suggestion has been made already. If you decide to work on an issue, or feel like taking initiative and contributing anything at all, feel free to create a pull request and I will get back to you shortly.
+Your feedback and contributions are welcome. If you have a suggestion, please raise an issue. Prior to that, please search through the issues first in case your suggestion has been made already. If you decide to work on an issue, please create a pull request.
 
 Pull requests should provide some basic context and link the relevant issue. Here is an [example pull request](https://github.com/a-synchronous/rubico/pull/12). If you are interested in contributing, the [help wanted](https://github.com/a-synchronous/rubico/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) tag is a good place to start.
 
@@ -260,11 +262,6 @@ rubico is [MIT Licensed](https://github.com/a-synchronous/rubico/blob/master/LIC
 # Awesome Resources
 [rubico simplifies asynchronous code](https://dev.to/richytong/rubico-a-synchrnous-functional-syntax-motivation-20hf)
 <br>
-[Practical Functional Programming in JavaScript - Side Effects and Purity](https://dev.to/richytong/practical-functional-programming-in-javascript-side-effects-and-purity-revised-420h)
-<br>
-[Practical Functional Programming in JavaScript - Techniques for Composing Data](https://dev.to/richytong/practical-functional-programming-in-javascript-techniques-for-composing-data-c39)
-<br>
-[Practical Functional Programming in JavaScript - Error Handling](https://dev.to/richytong/practical-functional-programming-in-javascript-error-handling-8g5)
 
 # Blog
 Check out the rubico blog at [https://rubico.land/blog](https://rubico.land/blog)

package/Transducer.d.ts

@@ -16,12 +16,12 @@
  * ```
  *
  * @description
- * Creates a mapping transducer. Items in the final reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a mapping transducer. Elements in the final reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const square = number => number ** 2
  *
- * const concat = (array, item) => array.concat(item)
+ * const concat = (array, element) => array.concat(element)
  *
  * const mapSquare = Transducer.map(square)
  * // mapSquare is a transducer
@@ -66,12 +66,12 @@ export function map(mapper: any): (arg0: any) => any;
  * ```
  *
  * @description
- * Creates a filtering transducer. A filtering reducer skips items of reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a filtering transducer. A filtering reducer skips elements of reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const concat = (array, item) => array.concat(item)
+ * const concat = (array, element) => array.concat(element)
  *
  * const concatOddNumbers = filter(isOdd)(concat)
  *
@@ -99,7 +99,7 @@ export function filter(predicate: any): (arg0: any) => any;
  * ```
  *
  * @description
- * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapping function to each item of the reducing operation, concatenating the results of the flatMapper execution into the final result. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapping function to each element of the reducing operation, concatenating the results of the flatMapper execution into the final result. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const powers = number => [number, number ** 2, number ** 3]
@@ -132,7 +132,7 @@ export function flatMap(flatMapper: any): (arg0: any) => any;
  * ```
  *
  * @description
- * Creates an effectful pasthrough transducer. The effectful passthrough transducer applies the effectful function to each item of the reducing operation, leaving the reducing operation unchanged. It is possible to use an asynchronous effectful function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates an effectful pasthrough transducer. The effectful passthrough transducer applies the effectful function to each element of the reducing operation, leaving the reducing operation unchanged. It is possible to use an asynchronous effectful function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const numbers = [1, 2, 3, 4, 5]
@@ -161,7 +161,7 @@ export function forEach(func: any): (arg0: any) => any;
  * ```
  *
  * @description
- * Creates a pasthrough transducer. The passthrough transducer passes each item of the reducing operation through, leaving the reducing operation unchanged.
+ * Creates a pasthrough transducer. The passthrough transducer passes each element of the reducing operation through, leaving the reducing operation unchanged.
  *
  * ```javascript [playground]
  * const createAsyncNumbers = async function* () {
@@ -184,7 +184,7 @@ export function passthrough(reducer: any): any;
  * ```coffeescript [specscript]
  * type Reducer = (
  *   accumulator any,
- *   item any,
+ *   element any,
  *   indexOrKey? number|string,
  *   collection? Foldable,
  * )=>(nextAccumulator Promise|any)
@@ -193,12 +193,12 @@ export function passthrough(reducer: any): any;
  *
  * Transducer.tryCatch(
  *   transducerTryer Transducer,
- *   catcher (error Error, item any)=>Promise|any,
+ *   catcher (error Error, element any)=>Promise|any,
  * ) -> tryCatchTransducer Transducer
  * ```
  *
  * @description
- * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the original item (before any processing by the transducer) for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the original element (before any processing by the transducer) for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const db = new Map()

package/Transducer.js

@@ -21,23 +21,22 @@ const Transducer = {}
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   value any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type UnarySyncOrAsyncMapper = (element any)=>(resultElement Promise|any)
  *
- * type Transducer = Reducer=>Reducer
+ * mapper UnarySyncOrAsyncMapper
  *
- * Transducer.map(mapperFunc function) -> mappingTransducer Transducer
+ * Transducer.map(mapper) -> mappingTransducer Transducer
  * ```
  *
  * @description
- * Creates a mapping transducer. Items in the final reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a mapping transducer. Elements of the transducer's reducing operation are transformed by the mapper function. It is possible to use an asynchronous mapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const square = number => number ** 2
  *
- * const concat = (array, item) => array.concat(item)
+ * const concat = (array, element) => array.concat(element)
  *
  * const mapSquare = Transducer.map(square)
  * // mapSquare is a transducer
@@ -81,29 +80,32 @@ Transducer.map = function transducerMap(mapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   value any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type UnarySyncOrAsyncPredicate = any=>Promise|boolean|any
  *
- * type Transducer = Reducer=>Reducer
+ * predicate UnarySyncOrAsyncPredicate
  *
- * Transducer.filter(predicate function) -> filteringTransducer Transducer
+ * Transducer.filter(predicate) -> filteringTransducer Transducer
  * ```
  *
  * @description
- * Creates a filtering transducer. A filtering reducer skips items of reducing operation if they test falsy by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a filtering transducer. A filtering transducer filters out elements of its reducing operation if they test false by the predicate. It is possible to use an asynchronous predicate, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const isOdd = number => number % 2 == 1
  *
- * const concat = (array, item) => array.concat(item)
+ * const concat = (array, element) => array.concat(element)
  *
- * const concatOddNumbers = filter(isOdd)(concat)
+ * const concatOddNumbers = Transducer.filter(isOdd)(concat)
  *
- * console.log(
- *   [1, 2, 3, 4, 5].reduce(concatOddNumbers, []),
- * ) // [1, 3, 5]
+ * const array = [1, 2, 3, 4, 5]
+ *
+ * const oddNumbers1 = array.reduce(concatOddNumbers, [])
+ * console.log(oddNumbers1) // [1, 3, 5]
+ *
+ * const oddNumbers2 = transform(array, Transducer.filter(isOdd), [])
+ * console.log(oddNumbers2) // [1, 3, 5]
  * ```
  *
  * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
@@ -126,18 +128,18 @@ Transducer.filter = function transducerFilter(predicate) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   value any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type Monad = Array|String|Set|Generator|AsyncGenerator|{ flatMap: string }|{ chain: string }|Object
+ * type UnarySyncOrAsyncFlatMapper = (element any)=>(monad Promise|Monad|any)
  *
- * type Transducer = Reducer=>Reducer
+ * flatMapper UnarySyncOrAsyncFlatMapper
  *
  * Transducer.flatMap(flatMapper) -> flatMappingTransducer Transducer
  * ```
  *
  * @description
- * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapping function to each item of the reducing operation, concatenating the results of the flatMapper execution into the final result. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates a flatMapping transducer. A flatMapping transducer applies the flatMapper function to each element of its reducing operation, concatenating the results of the flatMapper execution onto the accumulator. It is possible to use an asynchronous flatMapper, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const powers = number => [number, number ** 2, number ** 3]
@@ -169,25 +171,24 @@ Transducer.flatMap = function transducerFlatMap(flatMapper) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   value any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
+ * type UnarySyncOrAsyncCallback = (element any)=>Promise|undefined
  *
- * type Transducer = Reducer=>Reducer
+ * callback UnarySyncOrAsyncCallback
  *
- * Transducer.forEach(func function) -> forEachTransducer Transducer
+ * Transducer.forEach(callback) -> forEachTransducer Transducer
  * ```
  *
  * @description
- * Creates an effectful pasthrough transducer. The effectful passthrough transducer applies the effectful function to each item of the reducing operation, leaving the reducing operation unchanged. It is possible to use an asynchronous effectful function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Executes a callback function for each element of a reducing operation, leaving the reducing operation unmodified. It is possible to use an asynchronous callback function, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const numbers = [1, 2, 3, 4, 5]
- * transform(numbers, compose([
+ * transform(numbers, compose(
  *   Transducer.map(number => number ** 2),
  *   Transducer.forEach(console.log), // 1 4 9 16 25
- * ]), null)
+ * ), null)
  * ```
  *
  * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).
@@ -210,18 +211,14 @@ Transducer.forEach = function transducerForEach(func) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   value any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
  *
- * type Transducer = Reducer=>Reducer
- *
- * Transducer.passthrough(func function) -> passthroughTransducer Transducer
+ * Transducer.passthrough Transducer
  * ```
  *
  * @description
- * Creates a pasthrough transducer. The passthrough transducer passes each item of the reducing operation through, leaving the reducing operation unchanged.
+ * Creates a pasthrough transducer. The passthrough transducer simply passes each element of the reducing operation through to the next downstream operation, leaving the reducing operation unmodified.
  *
  * ```javascript [playground]
  * const createAsyncNumbers = async function* () {
@@ -256,21 +253,17 @@ Transducer.passthrough = function transducerPassthrough(reducer) {
  *
  * @synopsis
  * ```coffeescript [specscript]
- * type Reducer = (
- *   accumulator any,
- *   item any,
- * )=>(nextAccumulator Promise|any)
+ * type SyncOrAsyncReducer = (accumulator any, value any)=>(nextAccumulator Promise|any)
+ * type Transducer = SyncOrAsyncReducer=>SyncOrAsyncReducer
  *
- * type Transducer = Reducer=>Reducer
+ * transducerTryer Transducer
+ * catcher (error Error, element any)=>Promise|any
  *
- * Transducer.tryCatch(
- *   transducerTryer Transducer,
- *   catcher (error Error, item any)=>Promise|any,
- * ) -> tryCatchTransducer Transducer
+ * Transducer.tryCatch(transducerTryer, catcher) -> tryCatchTransducer Transducer
  * ```
  *
  * @description
- * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the original item (before any processing by the transducer) for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
+ * Creates an error handling transducer. The error handling transducer wraps a transducer and catches any errors thrown by the transducer with the catcher function. The catcher function is provided the error as well as the element for which the error was thrown. It is possible for either the transducer or the catcher to be asynchronous, however the reducing operation must support asynchronous execution. This library provides such implementations as [reduce](/docs/reduce) and [transform](/docs/transform).
  *
  * ```javascript [playground]
  * const db = new Map()
@@ -281,22 +274,25 @@ Transducer.passthrough = function transducerPassthrough(reducer) {
  *
  * const userIds = ['a', 'b', 'c', 'd', 'e']
  *
- * transform(userIds, Transducer.tryCatch(compose([
- *   Transducer.map(async userId => {
- *     if (db.has(userId)) {
- *       return db.get(userId)
- *     }
- *     throw new Error(`user ${userId} not found`)
- *   }),
- *
- *   Transducer.forEach(user => {
- *     console.log('Found', user.name)
- *   })
- * ]), (error, userId) => {
- *   console.error(error)
- *   console.log('userId in catcher:', userId)
- *   // original userId for which the error was thrown is provided
- * }), null)
+ * transform(userIds, Transducer.tryCatch(
+ *   compose(
+ *     Transducer.map(async userId => {
+ *       if (db.has(userId)) {
+ *         return db.get(userId)
+ *       }
+ *       throw new Error(`user ${userId} not found`)
+ *     }),
+ *
+ *     Transducer.forEach(user => {
+ *       console.log('Found', user.name)
+ *     })
+ *   ),
+ *   (error, userId) => {
+ *     console.error(error)
+ *     console.log('userId in catcher:', userId)
+ *     // original userId for which the error was thrown is provided
+ *   }
+ * ), null)
  * ```
  *
  * Read more on [transducers](/blog/transducers-crash-course-rubico-v2).

package/__.js

@@ -5,7 +5,7 @@ const __ = require('./_internal/placeholder')
  *
  * @synopsis
  * ```coffeescript [specscript]
- * __ Symbol
+ * __ Symbol(placeholder)
  * ```
  *
  * @description

package/_internal/FlatMappingIterator.js

@@ -33,7 +33,7 @@ const FlatMappingIterator = function (iterator, flatMapper) {
       const monadAsArray = genericReduce(
         flatMapper(iteration.value),
         arrayPush,
-        []) // this will always have at least one item
+        []) // this will always have at least one element
       if (monadAsArray.length > 1) {
         buffer = monadAsArray
         bufferIndex = 1

package/_internal/MappingIterator.d.ts

@@ -14,7 +14,7 @@ export = MappingIterator;
  * ```
  *
  * @description
- * Creates a mapping iterator, i.e. an iterator that applies a mapper to each item of a source iterator.
+ * Creates a mapping iterator, i.e. an iterator that applies a mapper to each element of a source iterator.
  *
  * Note: consuming the mapping iterator also consumes the source iterator.
  */

package/_internal/MappingIterator.js

@@ -15,7 +15,7 @@ const symbolIterator = require('./symbolIterator')
  * ```
  *
  * @description
- * Creates a mapping iterator, i.e. an iterator that applies a mapper to each item of a source iterator.
+ * Creates a mapping iterator, i.e. an iterator that applies a mapper to each element of a source iterator.
  *
  * Note: consuming the mapping iterator also consumes the source iterator.
  */

package/_internal/arrayFilter.js

@@ -25,15 +25,15 @@ const arrayFilter = function (array, predicate) {
   let index = -1,
     resultIndex = -1
   while (++index < arrayLength) {
-    const item = array[index],
-      shouldIncludeItem = predicate(item, index, array)
-    if (isPromise(shouldIncludeItem)) {
+    const element = array[index],
+      shouldIncludeElement = predicate(element, index, array)
+    if (isPromise(shouldIncludeElement)) {
       return promiseAll(
-        arrayExtendMap([shouldIncludeItem], array, predicate, index)
+        arrayExtendMap([shouldIncludeElement], array, predicate, index)
       ).then(curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
-    if (shouldIncludeItem) {
-      result[++resultIndex] = item
+    if (shouldIncludeElement) {
+      result[++resultIndex] = element
     }
   }
   return result

package/_internal/arrayFilterIndexes.js

@@ -24,17 +24,17 @@ const arrayFilterIndexes = function (predicate, array) {
   let index = -1,
     resultIndex = -1
   while (++index < arrayLength) {
-    const item = array[index],
-      shouldIncludeItem = predicate(index)
-    if (isPromise(shouldIncludeItem)) {
-      const predicationPromises = [shouldIncludeItem]
+    const element = array[index],
+      shouldIncludeElement = predicate(index)
+    if (isPromise(shouldIncludeElement)) {
+      const predicationPromises = [shouldIncludeElement]
       return promiseAll(
         arrayExtendMapIndexes(
-          [shouldIncludeItem], array, predicate, index)).then(
+          [shouldIncludeElement], array, predicate, index)).then(
             curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
-    if (shouldIncludeItem) {
-      result[++resultIndex] = item
+    if (shouldIncludeElement) {
+      result[++resultIndex] = element
     }
   }
   return result

package/_internal/arrayFilterWithIndex.js

@@ -27,16 +27,16 @@ const arrayFilterWithIndex = function (array, predicate) {
   let index = -1,
     resultIndex = -1
   while (++index < arrayLength) {
-    const item = array[index],
-      shouldIncludeItem = predicate(item, index, array)
-    if (isPromise(shouldIncludeItem)) {
+    const element = array[index],
+      shouldIncludeElement = predicate(element, index, array)
+    if (isPromise(shouldIncludeElement)) {
       return promiseAll(
         arrayExtendMapWithIndex(
-          [shouldIncludeItem], array, predicate, index)).then(
+          [shouldIncludeElement], array, predicate, index)).then(
             curry4(arrayFilterByConditions, array, result, index - 1, __))
     }
-    if (shouldIncludeItem) {
-      result[++resultIndex] = item
+    if (shouldIncludeElement) {
+      result[++resultIndex] = element
     }
   }
   return result

package/_internal/arrayFind.js

@@ -21,13 +21,13 @@ const always = require('./always')
 const arrayFindAsync = async function (array, predicate, index) {
   const length = array.length
   while (++index < length) {
-    const item = array[index]
-    let predication = predicate(item)
+    const element = array[index]
+    let predication = predicate(element)
     if (isPromise(predication)) {
       predication = await predication
     }
     if (predication) {
-      return item
+      return element
     }
   }
   return undefined
@@ -50,16 +50,16 @@ const arrayFind = function (array, predicate) {
   const length = array.length
   let index = -1
   while (++index < length) {
-    const item = array[index],
-      predication = predicate(item)
+    const element = array[index],
+      predication = predicate(element)
     if (isPromise(predication)) {
       return predication.then(curry3(
         thunkConditional,
         __,
-        always(item),
+        always(element),
         thunkify3(arrayFindAsync, array, predicate, index)))
     } else if (predication) {
-      return item
+      return element
     }
   }
   return undefined

package/_internal/arrayFlatten.js

@@ -37,44 +37,44 @@ const arrayFlatten = function (array) {
   let index = -1
 
   while (++index < length) {
-    const item = array[index]
-    if (isArray(item)) {
-      const itemLength = item.length
-      let itemIndex = -1
-      while (++itemIndex < itemLength) {
-        result.push(item[itemIndex])
+    const element = array[index]
+    if (isArray(element)) {
+      const elementLength = element.length
+      let elementIndex = -1
+      while (++elementIndex < elementLength) {
+        result.push(element[elementIndex])
       }
-    } else if (item == null) {
-      result.push(item)
-    } else if (typeof item.then == 'function') {
-      promises.push(item.then(curry2(arrayPush, result, __)))
-    } else if (typeof item[symbolIterator] == 'function') {
-      for (const subItem of item) {
-        result.push(subItem)
+    } else if (element == null) {
+      result.push(element)
+    } else if (typeof element.then == 'function') {
+      promises.push(element.then(curry2(arrayPush, result, __)))
+    } else if (typeof element[symbolIterator] == 'function') {
+      for (const subElement of element) {
+        result.push(subElement)
       }
-    } else if (typeof item[symbolAsyncIterator] == 'function') {
+    } else if (typeof element[symbolAsyncIterator] == 'function') {
       promises.push(asyncIteratorForEach(
-        item[symbolAsyncIterator](), curry2(arrayPush, result, __)))
-    } else if (typeof item.chain == 'function') {
-      const monadValue = item.chain(identity)
+        element[symbolAsyncIterator](), curry2(arrayPush, result, __)))
+    } else if (typeof element.chain == 'function') {
+      const monadValue = element.chain(identity)
       isPromise(monadValue)
         ? promises.push(monadValue.then(curry2(arrayPush, result, __)))
         : result.push(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(curry2(arrayPush, result, __)))
         : result.push(monadValue)
-    } else if (typeof item.reduce == 'function') {
-      const folded = item.reduce(funcConcatSync(
+    } else if (typeof element.reduce == 'function') {
+      const folded = element.reduce(funcConcatSync(
         getArg1, curry2(arrayPush, result, __)), null)
       isPromise(folded) && promises.push(folded)
-    } else if (item.constructor == Object) {
-      for (const key in item) {
-        result.push(item[key])
+    } else if (element.constructor == Object) {
+      for (const key in element) {
+        result.push(element[key])
       }
     } else {
-      result.push(item)
+      result.push(element)
     }
   }
   return promises.length == 0

package/_internal/arrayForEach.d.ts

@@ -12,7 +12,7 @@ export = arrayForEach;
  * ```
  *
  * @description
- * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an iterator. Return a promise if any executions are asynchronous.
  *
  * Note: iterator is consumed
  */

package/_internal/arrayForEach.js

@@ -15,7 +15,7 @@ const always = require('./always')
  * ```
  *
  * @description
- * Call a callback for each item of an iterator. Return a promise if any executions are asynchronous.
+ * Call a callback for each element of an iterator. Return a promise if any executions are asynchronous.
  *
  * Note: iterator is consumed
  */