rubico 2.0.0 → 2.1.0

package/README.md

@@ -19,90 +19,68 @@ const isOdd = number => number % 2 == 1
 
 const asyncSquare = async number => number ** 2
 
-const squaredOdds = pipe([
+const numbers = [1, 2, 3, 4, 5]
+
+pipe(numbers, [
   filter(isOdd),
   map(asyncSquare),
+  console.log, // [1, 9, 25]
 ])
-
-squaredOdds([1, 2, 3, 4, 5]).then(console.log) // [1, 9, 25]
 ```
 
 # Installation
-[Core build](https://unpkg.com/rubico/index.js) ([~6.1 kB minified and gzipped](https://unpkg.com/rubico/dist/rubico.min.js))
+[Core build](https://unpkg.com/rubico/index.js) ([~6.8 kB minified and gzipped](https://unpkg.com/rubico/dist/rubico.min.js))
 
 with `npm`
 ```bash
 npm i rubico
 ```
 
-require `rubico` in Node.js
+require `rubico` in CommonJS.
 ```javascript
+// import rubico core globally
+require('rubico/global')
+
+// import rubico core as rubico
 const rubico = require('rubico')
+
+// import an operator from rubico core
 const pipe = require('rubico/pipe')
-const tap = require('rubico/tap')
+
+// import rubico/x as x
+const x = require('rubico/x')
+
+// import an operator from rubico/x
 const defaultsDeep = require('rubico/x/defaultsDeep')
+
+// import rubico's Transducer module
+const Transducer = require('rubico/Transducer')
 ```
 
-import `rubico` globally
+import `rubico` in the browser.
 ```html [htmlmixed]
-<script src="https://unpkg.com/rubico"></script>
-<script src="https://unpkg.com/rubico/dist/pipe.js"></script>
-<script src="https://unpkg.com/rubico/dist/tap.js"></script>
-<script src="https://unpkg.com/rubico/dist/x/defaultsDeep.js"></script>
-<script>
-console.log(rubico) // { pipe, tap, ... }
-console.log(pipe) // [Function: pipe]
-console.log(tap) // [Function: tap]
-console.log(defaultsDeep) // [Function: defaultsDeep]
-</script>
-
-<!-- minified -->
+<!-- import rubico core globally -->
+<script src="https://unpkg.com/rubico/dist/global.min.js"></script>
+
+<!-- import rubico core as rubico -->
 <script src="https://unpkg.com/rubico/dist/rubico.min.js"></script>
+
+<!-- import an operator from rubico core -->
 <script src="https://unpkg.com/rubico/dist/pipe.min.js"></script>
-<script src="https://unpkg.com/rubico/dist/tap.min.js"></script>
-<script src="https://unpkg.com/rubico/dist/x/defaultsDeep.min.js"></script>
-<script>
-console.log(rubico) // { pipe, tap, ... }
-console.log(pipe) // [Function: pipe]
-console.log(tap) // [Function: tap]
-console.log(defaultsDeep) // [Function: defaultsDeep]
-</script>
-```
 
-import `rubico` in the browser via ES ([JavaScript](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Modules)) Modules
-```javascript
-import rubico from 'https://unpkg.com/rubico/dist/rubico.es.js'
-import pipe from 'https://unpkg.com/rubico/dist/pipe.es.js'
-import tap from 'https://unpkg.com/rubico/dist/tap.es.js'
-import defaultsDeep from 'https://unpkg.com/rubico/dist/x/defaultsDeep.es.js'
-
-// minified
-import rubico from 'https://unpkg.com/rubico/dist/rubico.es.min.js'
-import pipe from 'https://unpkg.com/rubico/dist/pipe.es.min.js'
-import tap from 'https://unpkg.com/rubico/dist/tap.es.min.js'
-import defaultsDeep from 'https://unpkg.com/rubico/dist/x/defaultsDeep.es.min.js'
-```
+<!-- import an operator from rubico/x -->
+<script src="https://unpkg.com/rubico/dist/x/defaultsDeep.min.js"></script>
 
-import `rubico` as ESM in Node 16 and up
-```javascript
-import rubico from 'rubico/dist/rubico.mjs'
-import pipe from 'rubico/dist/pipe.mjs'
-import tap from 'rubico/dist/tap.mjs'
-import defaultsDeep from 'rubico/dist/x/defaultsDeep.mjs'
-
-// minified
-import rubico from 'rubico/dist/rubico.min.mjs'
-import pipe from 'rubico/dist/pipe.min.mjs'
-import tap from 'rubico/dist/tap.min.mjs'
-import defaultsDeep from 'rubico/dist/x/defaultsDeep.min.mjs'
+<!-- import rubico's Transducer module -->
+<script src="https://unpkg.com/rubico/dist/Transducer.min.js"></script>
 ```
 
 # Motivation
 
 A note from the author
-> At a certain point in my career, I grew frustrated with the entanglement of my own code. While looking for something better, I found functional programming. I was excited by the idea of functional composition, but disillusioned by the redundancy of effectful types. I started Rubico to capitalize on the prior while rebuking the latter. Many iterations since then, the library has grown into something I personally enjoy using, and continue to use to this day.
+> At a certain point in my career, I grew frustrated with the entanglement of my own code. While looking for something better, I found functional programming. I was excited by the idea of functional composition, but disillusioned by the redundancy of effectful types. I started rubico to capitalize on the prior while rebuking the latter. Many iterations since then, the library has grown into something I personally enjoy using, and continue to use to this day.
 
-Rubico is founded on the following principles:
+rubico is founded on the following principles:
  * asynchronous code should be simple
  * functional style should not care about async
  * functional transformations should be composable, performant, and simple to express
@@ -111,54 +89,153 @@ When you import this library, you obtain the freedom that comes from having thos
 
 # Introduction
 
-Rubico is a module of twenty-nine operators for async-enabled functional programming in JavaScript.
+rubico is a library for async-enabled functional programming in JavaScript. The library methods support a simple and composable functional style in asynchronous environments.
 
 ```javascript
 const {
-  pipe, tap,
-  switchCase, tryCatch,
-  fork, assign, get, set, pick, omit,
+  // compose functions
+  pipe, compose,
+
+  // compose effects
+  tap, forEach,
+
+  // control flow
+  switchCase,
+
+  // handle errors
+  tryCatch,
+
+  // compose objects
+  all, assign, get, set, pick, omit,
+
+  // transform data
   map, filter, reduce, transform, flatMap,
-  and, or, not, any, all,
+
+  // compose predicates
+  and, or, not, some, every,
+
+  // comparison operators
   eq, gt, lt, gte, lte,
-  thunkify, always,
-  curry, __,
+
+  // partial application
+  thunkify, always, curry, __,
 } = rubico
 ```
 
-These operators act sensibly on a wide range of vanilla JavaScript types to create declarative, extensible, and async-enabled function compositions.
+With async-enabled, or [a]synchronous, functional programming, functions provided to the rubico methods may be asynchronous and return a Promise. Any promises in argument position are also resolved before continuing with the operation.
 
 ```javascript [playground]
-const { pipe, map } = rubico
+const helloPromise = Promise.resolve('hello')
 
-const toTodosUrl = id => `https://jsonplaceholder.typicode.com/todos/${id}`
+pipe(helloPromise, [ // helloPromise is resolved for 'hello'
+  async greeting => `${greeting} world`,
+  // the Promise returned from the async function is resolved
+  // and the resolved value is passed to console.log
 
-const logTodoByID = pipe([ // fetch a Todo and log it
-  toTodosUrl,
-  fetch,
-  response => response.json(),
-  console.log,
+  console.log, // hello world
 ])
+```
+
+Most methods support both an eager and a tacit API. The eager API takes all required arguments and executes at once, while its tacit 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.
+
+```javascript [playground]
+const myObj = { a: 1, b: 2, c: 3 }
+
+// the first use of map is eager
+const myDuplicatedSquaredObject = map(myObj, pipe([
+  number => [number, number],
+
+  // the second use of map is tacit
+  map(number => number ** 2),
+]))
+
+console.log(myDuplicatedSquaredObject)
+// { a: [1, 1], b: [4, 4], c: [9, 9] }
+```
+
+The rubico methods are versatile and act on a wide range of vanilla JavaScript types to create declarative, extensible, and async-enabled function compositions. The same operator `map` can act on an array and also a `Map` data structure.
+
+```javascript [playground]
+const { pipe, tap, map, filter } = rubico
+
+const toTodosUrl = id => `https://jsonplaceholder.typicode.com/todos/${id}`
 
 const todoIDs = [1, 2, 3, 4, 5]
 
-map(logTodoByID)(todoIDs) // fetch Todos per id of TodoIDs and log them
-// { userId: 1, id: 4, title: 'et porro tempora', completed: true }
-// { userId: 1, id: 1, title: 'delectus aut autem', completed: false }
-// { userId: 1, id: 3, title: 'fugiat veniam minus', completed: false }
-// { userId: 1, id: 2, title: 'quis ut nam facilis...', completed: false }
-// { userId: 1, id: 5, title: 'laboriosam mollitia...', completed: false }
+pipe(todoIDs, [
+
+  // fetch todos per id of todoIDs
+  map(pipe([
+    toTodosUrl,
+    fetch,
+    response => response.json(),
+
+    tap(console.log),
+    // { userId: 1, id: 4, title: 'et porro tempora', completed: true }
+    // { userId: 1, id: 1, title: 'delectus aut autem', completed: false }
+    // { userId: 1, id: 3, title: 'fugiat veniam minus', completed: false }
+    // { userId: 1, id: 2, title: 'quis ut nam facilis...', completed: false }
+    // { userId: 1, id: 5, title: 'laboriosam mollitia...', completed: false }
+  ])),
+
+  // group the todos by userId in a new Map
+  function createUserTodosMap(todos) {
+    const userTodosMap = new Map()
+    for (const todo of todos) {
+      const { userId } = todo
+      if (userTodosMap.has(userId)) {
+        userTodosMap.get(userId).push(todo)
+      } else {
+        userTodosMap.set(userId, [todo])
+      }
+    }
+    return userTodosMap
+  },
+
+  // filter for completed todos
+  // map iterates through each value (array of todos) of the userTodosMap
+  // filter iterates through each todo of the arrays of todos
+  map(filter(function didComplete(todo) {
+    return todo.completed
+  })),
+
+  tap(console.log),
+  // Map(1) {
+  //   1 => [ { userId: 1, id: 4, title: 'et porro tempora', completed: true } ]
+  // }
+])
+```
+
+rubico offers transducers in its `Transducer` module. You can consume these transducers with the `transform` and `compose` methods. You should use `compose` over `pipe` to chain a left-to-right composition of transducers.
 
-// same as above but with limited concurrency
-// map.pool(2, logTodoByID)(todoIDs)
+```javascript [playground]
+const isOdd = number => number % 2 == 1
+
+const asyncSquare = async number => number ** 2
+
+const generateNumbers = function* () {
+  yield 1
+  yield 2
+  yield 3
+  yield 4
+  yield 5
+}
+
+pipe(generateNumbers(), [
+  transform(compose([
+    Transducer.filter(isOdd),
+    Transducer.map(asyncSquare),
+  ]), []),
+  console.log, // [1, 9, 25]
+])
 ```
 
-For advanced asynchronous use cases, check out some of Rubico's property functions:
+For advanced asynchronous use cases, some of the methods 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 even more advanced functions, please visit `rubico/x`. You can find the full method documentation at [rubico.land/docs](https://rubico.land/docs).
+For more functions beyond the core methods, please visit `rubico/x`. You can find the full documentation at [rubico.land/docs](https://rubico.land/docs).
 
 # 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.
@@ -166,7 +243,7 @@ Your feedback and contributions are welcome. If you have a suggestion, please ra
 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.
 
 # License
-Rubico is [MIT Licensed](https://github.com/a-synchronous/rubico/blob/master/LICENSE).
+rubico is [MIT Licensed](https://github.com/a-synchronous/rubico/blob/master/LICENSE).
 
 # Support
  * minimum Node.js version: 12

package/Transducer.js

@@ -3,7 +3,9 @@ const reducerMap = require('./_internal/reducerMap')
 const reducerFilter = require('./_internal/reducerFilter')
 const reducerFlatMap = require('./_internal/reducerFlatMap')
 const reducerForEach = require('./_internal/reducerForEach')
+const reducerTryCatch = require('./_internal/reducerTryCatch')
 const curry2 = require('./_internal/curry2')
+const curry3 = require('./_internal/curry3')
 const __ = require('./_internal/placeholder')
 
 /**
@@ -155,8 +157,34 @@ Transducer.forEach = function transducerForEach(func) {
   return curry2(reducerForEach, __, func)
 }
 
+/**
+ * @name Transducer.passthrough
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
+ *
+ * Transducer.passthrough(func function) -> passthroughTransducer Transducer
+ * ```
+ */
 Transducer.passthrough = function transducerPassthrough(reducer) {
   return reducer
 }
 
+/**
+ * @name Transducer.tryCatch
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Reducer = (accumulator any, item any)=>(nextAccumulator Promise|any)
+ * type Transducer = Reducer=>Reducer
+ *
+ * Transducer.tryCatch(func function) -> tryCatchTransducer Transducer
+ * ```
+ */
+Transducer.tryCatch = function transducerTryCatch(transducerTryer, catcher) {
+  return curry3(reducerTryCatch, __, transducerTryer, catcher)
+}
+
 module.exports = Transducer

package/Transducer.test.js

@@ -1,117 +1,154 @@
-const assert = require('assert')
+require('./global')
 const Transducer = require('./Transducer')
-const compose = require('./compose')
-const reduce = require('./reduce')
-const transform = require('./transform')
+const assert = require('assert')
 
 describe('Transducer', () => {
   const ade = assert.deepEqual
   const ase = assert.strictEqual
   const aok = assert.ok
 
-  describe('integration: transducers from Transducer.map, Transducer.filter, Transducer.flatMap', () => {
-    const concat = (y, xi) => y.concat(xi)
-    const add = (y, xi) => y + xi
-    const isOdd = number => number % 2 == 1
+  const concat = (y, xi) => y.concat(xi)
+  const add = (y, xi) => y + xi
+  const isOdd = number => number % 2 == 1
 
-    it('reduce with sync transduced reducers', async () => {
-      const squareOdds = compose([
-        Transducer.filter(isOdd),
-        Transducer.map(x => x ** 2),
-      ])
-      ade(
-        reduce(squareOdds(concat), [])([1, 2, 3, 4, 5]),
-        [1, 9, 25],
-      )
-      ade(
-        reduce(squareOdds((y, xi) => y.add(xi)), new Set())([1, 2, 3, 4, 5]),
-        new Set([1, 9, 25]),
-      )
-      const appendAlphas = compose([
-        Transducer.map(x => `${x}a`),
-        Transducer.map(x => `${x}b`),
-        Transducer.map(x => `${x}c`),
-      ])
-      ase(
-        reduce(appendAlphas(add), '')('123'),
-        '1abc2abc3abc',
-      )
-      ade(
-        reduce(appendAlphas(concat), [])('123'),
-        ['1abc', '2abc', '3abc'],
-      )
-    })
+  it('reduce with sync transduced reducers', async () => {
+    const squareOdds = compose([
+      Transducer.filter(isOdd),
+      Transducer.map(x => x ** 2),
+    ])
+    ade(
+      reduce(squareOdds(concat), [])([1, 2, 3, 4, 5]),
+      [1, 9, 25],
+    )
+    ade(
+      reduce(squareOdds((y, xi) => y.add(xi)), new Set())([1, 2, 3, 4, 5]),
+      new Set([1, 9, 25]),
+    )
+    const appendAlphas = compose([
+      Transducer.map(x => `${x}a`),
+      Transducer.map(x => `${x}b`),
+      Transducer.map(x => `${x}c`),
+    ])
+    ase(
+      reduce(appendAlphas(add), '')('123'),
+      '1abc2abc3abc',
+    )
+    ade(
+      reduce(appendAlphas(concat), [])('123'),
+      ['1abc', '2abc', '3abc'],
+    )
+  })
 
-    it('reduce with an async transduced reducer', async () => {
-      const hosWithHey = compose([
-        Transducer.filter(async x => x === 'ho'),
-        Transducer.map(x => Promise.resolve(`${x}hey`)),
-      ])
-      const hihos = { a: 'hi', b: 'ho', c: 'hi', d: 'ho', e: 'hi', f: 'ho' }
-      aok(reduce(hosWithHey(add), '')(hihos) instanceof Promise),
-      aok(reduce(hosWithHey(concat), [])(hihos) instanceof Promise),
-      ase(
-        await reduce(hosWithHey(add), '')(hihos),
-        'hoheyhoheyhohey',
-      )
-      ade(
-        await reduce(hosWithHey(concat), [])(hihos),
-        ['hohey', 'hohey', 'hohey'],
-      )
-    })
+  it('reduce with an async transduced reducer', async () => {
+    const hosWithHey = compose([
+      Transducer.filter(async x => x === 'ho'),
+      Transducer.map(x => Promise.resolve(`${x}hey`)),
+    ])
+    const hihos = { a: 'hi', b: 'ho', c: 'hi', d: 'ho', e: 'hi', f: 'ho' }
+    aok(reduce(hosWithHey(add), '')(hihos) instanceof Promise),
+    aok(reduce(hosWithHey(concat), [])(hihos) instanceof Promise),
+    ase(
+      await reduce(hosWithHey(add), '')(hihos),
+      'hoheyhoheyhohey',
+    )
+    ade(
+      await reduce(hosWithHey(concat), [])(hihos),
+      ['hohey', 'hohey', 'hohey'],
+    )
+  })
 
-    it('flatMapping transducer', async () => {
-      const createOddMultiplesSync = compose([
-        Transducer.filter(isOdd),
-        Transducer.flatMap(number => [number * 2, number * 3]),
-      ])
+  it('transform with error handling on a transducer composition', async () => {
+    const caughtErrors = []
+    const numbers = [1, 2, 3, 4, 5]
+    const result = await transform(numbers, Transducer.tryCatch(compose([
+      Transducer.filter(number => number % 2 == 1),
+      Transducer.map(number => number ** 2),
+      Transducer.map(number => {
+        throw new Error(number)
+      }),
+      Transducer.map(number => number * 10), // should never reach here
+    ]), (error, item) => {
+      caughtErrors.push(error)
+      return item
+    }), [])
+    assert.equal(caughtErrors.length, 3)
+    assert.deepEqual(result, [1, 3, 5])
+    assert.deepEqual(caughtErrors.map(get('message')), ['1', '9', '25'])
+  })
 
-      ase(
-        reduce([1, 2, 3], createOddMultiplesSync(add), 0),
-        2 + 3 + 6 + 9,
-      )
-      ade(
-        reduce([1, 2, 3], createOddMultiplesSync(concat), []),
-        [2, 3, 6, 9],
-      )
+  it('transform with error handling on a transducer in a composition', async () => {
+    const caughtErrors = []
+    const numbers = [1, 2, 3, 4, 5]
+    const result = await transform(numbers, compose([
+      Transducer.filter(number => number % 2 == 1),
+      Transducer.map(number => number ** 2),
+      Transducer.tryCatch(
+        Transducer.map(number => {
+          throw new Error(number)
+        }),
+        (error, item) => {
+          caughtErrors.push(error)
+          return item
+        },
+      ),
+      Transducer.map(number => number * 10), // should reach here with error handler
+    ]), [])
+    assert.equal(caughtErrors.length, 3)
+    assert.deepEqual(result, [10, 90, 250])
+    assert.deepEqual(caughtErrors.map(get('message')), ['1', '9', '25'])
+  })
 
-      const createOddMultiplesAsync = compose([
-        Transducer.filter(isOdd),
-        Transducer.flatMap(async number => [number * 2, number * 3]),
-      ])
+  it('flatMapping transducer', async () => {
+    const createOddMultiplesSync = compose([
+      Transducer.filter(isOdd),
+      Transducer.flatMap(number => [number * 2, number * 3]),
+    ])
 
-      const p1 = reduce([1, 2, 3], createOddMultiplesAsync(add), 0)
-      aok(p1 instanceof Promise)
-      const p2 = reduce([1, 2, 3], createOddMultiplesAsync(concat), [])
-      aok(p2 instanceof Promise)
-      await p1.then(result => {
-        ase(result, 2 + 3 + 6 + 9)
-      })
-      await p2.then(result => {
-        ade(result, [2, 3, 6, 9])
-      })
-    })
+    ase(
+      reduce([1, 2, 3], createOddMultiplesSync(add), 0),
+      2 + 3 + 6 + 9,
+    )
+    ade(
+      reduce([1, 2, 3], createOddMultiplesSync(concat), []),
+      [2, 3, 6, 9],
+    )
 
-    it('forEach transducer', async () => {
-      let sum1 = 0
-      reduce([1, 2, 3, 4, 5], Transducer.forEach(number => {
-        sum1 += number
-      })(() => {}), null)
-      assert.equal(sum1, 15)
+    const createOddMultiplesAsync = compose([
+      Transducer.filter(isOdd),
+      Transducer.flatMap(async number => [number * 2, number * 3]),
+    ])
 
-      let sum2 = 0
-      await reduce([1, 2, 3, 4, 5], Transducer.forEach(async number => {
-        sum2 += number
-      })(() => {}), null)
-      assert.equal(sum2, 15)
+    const p1 = reduce([1, 2, 3], createOddMultiplesAsync(add), 0)
+    aok(p1 instanceof Promise)
+    const p2 = reduce([1, 2, 3], createOddMultiplesAsync(concat), [])
+    aok(p2 instanceof Promise)
+    await p1.then(result => {
+      ase(result, 2 + 3 + 6 + 9)
     })
-
-    it('passthrough transducer', async () => {
-      assert.deepEqual(
-        transform({ a: 1, b: 2, c: 3 }, Transducer.passthrough, []),
-        [1, 2, 3],
-      )
+    await p2.then(result => {
+      ade(result, [2, 3, 6, 9])
     })
   })
 
+  it('forEach transducer', async () => {
+    let sum1 = 0
+    reduce([1, 2, 3, 4, 5], Transducer.forEach(number => {
+      sum1 += number
+    })(() => {}), null)
+    assert.equal(sum1, 15)
+
+    let sum2 = 0
+    await reduce([1, 2, 3, 4, 5], Transducer.forEach(async number => {
+      sum2 += number
+    })(() => {}), null)
+    assert.equal(sum2, 15)
+  })
+
+  it('passthrough transducer', async () => {
+    assert.deepEqual(
+      transform({ a: 1, b: 2, c: 3 }, Transducer.passthrough, []),
+      [1, 2, 3],
+    )
+  })
+
 })

package/_internal/reducerTryCatch.js

@@ -0,0 +1,55 @@
+const isPromise = require('./isPromise')
+const __ = require('./placeholder')
+const curry5 = require('./curry5')
+const curry2 = require('./curry2')
+
+/**
+ * @name _reducerTryCatchErrorHandler
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * _reducerTryCatchErrorHandler(
+ *   reducer function,
+ *   error Error,
+ *   accum any,
+ *   item any,
+ * ) -> Promise|any
+ * ```
+ */
+const _reducerTryCatchErrorHandler = function (
+  catcher, reducer, error, accum, item,
+) {
+  const c = catcher(error, item)
+  return isPromise(c) ? c.then(curry2(reducer, accum, __)) : reducer(accum, c)
+}
+
+/**
+ * @name reducerTryCatch
+ *
+ * @synopsis
+ * ```coffeescript [specscript]
+ * type Reducer = (accum any, item any)=>(nextAccumulator Promise|any)
+ *
+ * reducerTryCatch(
+ *   reducer function,
+ *   catcher function,
+ * ) -> errorHandlingReducer function
+ * ```
+ */
+const reducerTryCatch = function (reducer, transducerTryer, catcher) {
+  const finalReducer = transducerTryer(reducer)
+  return function errorHandlingReducer(accum, item) {
+    try {
+      const ret = finalReducer(accum, item)
+      return isPromise(ret) ? ret.catch(curry5(
+        _reducerTryCatchErrorHandler, catcher, reducer, __, accum, item,
+      )) : ret
+    } catch (error) {
+      return _reducerTryCatchErrorHandler(
+        catcher, reducer, error, accum, item,
+      )
+    }
+  }
+}
+
+module.exports = reducerTryCatch