feat: support for middlewares for recursive

Author: gtkatakura

README.md

@@ -6,13 +6,41 @@
 
 Create recursive functions with `Y-Combinator` style.
 ```js
+import { recursive } from 'recursive-func'
+
+const log = next => (...args) => {
+  const result = next(...args)
+
+  // will print from the last call to the first
+  console.log('Args = ', args)
+  console.log('Result = ', result)
+
+  return result
+}
+
+const middlewares = [log]
+
 const sum = recursive(self => ([head = 0, ...tail]) => {
   return tail.length === 0
     ? head
     : head + self(tail)
-})
+}, middlewares)
+
+const value = sum([1, 2, 3])
+
+// third call:
+//  Args = [[3]]
+//  Result = 3
+
+// second call:
+//  Args = [[2, 3]]
+//  Result = 5
+
+// first call:
+//  Args = [[1, 2, 3]]
+//  Result = 6
 
-sum([1, 2, 3]) // => 6
+console.log(value) // => 6
 ```
 
 [build-badge]: https://img.shields.io/travis/user/repo/master.png?style=flat-square

src/compose.js

@@ -0,0 +1,5 @@
+const base = (f, g) => (...args) => f(g(...args))
+
+const compose = (funcs) => funcs.reduce(base)
+
+export default compose

src/recursive.js

@@ -1,5 +1,17 @@
-const recursive = (func) => {
-  const wrapper = func((...args) => wrapper(...args))
+import compose from './compose'
+
+const applyMiddlewares = (middlewares, func) => (
+  middlewares.length !== 0
+    ? compose(middlewares)(func)
+    : func
+)
+
+const recursive = (func, middlewares = []) => {
+  const wrapper = applyMiddlewares(
+    middlewares,
+    func((...args) => wrapper(...args))
+  )
+
   return wrapper
 }
 

tests/index-test.js

@@ -3,38 +3,78 @@ import expect, { createSpy } from 'expect'
 import { recursive } from 'src/index'
 
 describe('recursive', () => {
+  let id
+  let constant
+
+  beforeEach(() => {
+    id = createSpy().andCall(value => value)
+    constant = createSpy().andCall(value => _ => value)
+  })
+
   it('should be a function', () => {
     expect(recursive).toBeA(Function)
   })
 
-  describe('recursive(identity)("one", "two")', () => {
-    let internal
-    let identity
+  describe('recursive(id)("one", "two")', () => {
+    let rec
 
     beforeEach(() => {
-      internal = createSpy().andCall(value => value)
-      identity = recursive(self => internal)
+      rec = recursive(self => id)
     })
 
-    const subject = () => identity('one', 'two')
+    const subject = () => rec('one', 'two')
 
     it('should be called with ("one", "two")', () => {
       subject()
 
-      expect(internal).toHaveBeenCalledWith('one', 'two')
+      expect(id).toHaveBeenCalledWith('one', 'two')
     })
 
     it('should be called 1 time', () => {
       subject()
 
-      expect(internal.calls.length).toEqual(1)
+      expect(id.calls.length).toEqual(1)
     })
 
     it('should return "one"', () => {
       expect(subject()).toEqual('one')
     })
   })
 
+  describe('recursive(id, [() => const("three")])("one", "two")', () => {
+    let subject
+    let middleware
+
+    beforeEach(() => {
+      middleware = createSpy().andCall(() => constant('three'))
+      subject = recursive(self => id, [
+        middleware,
+      ])
+    })
+
+    it('should not call λ(id)', () => {
+      subject()
+
+      expect(id).toNotHaveBeenCalled()
+    })
+
+    it('should call λ(middleware) with λ(id)', () => {
+      subject()
+
+      expect(middleware).toHaveBeenCalled(id)
+    })
+
+    it('should call λ(const) with λ(three)', () => {
+      subject()
+
+      expect(constant).toHaveBeenCalled('three')
+    })
+
+    it('should return "three"', () => {
+      expect(subject('one', 'two')).toEqual('three')
+    })
+  })
+
   describe('recursive(sum)([1, 2, 3])', () => {
     let internal
     let sum