feat: create withMiddlewares

Author: gtkatakura

README.md

@@ -7,6 +7,7 @@
 Create recursive functions with `Y-Combinator` style.
 ```js
 import { recursive } from 'recursive-func'
+import memoize from 'memoize'
 
 const log = next => (...args) => {
   const result = next(...args)
@@ -18,15 +19,18 @@ const log = next => (...args) => {
   return result
 }
 
-const middlewares = [log]
+const sum = recursive(
+  self => ([head = 0, ...tail]) => {
+    return tail.length === 0
+      ? head
+      : head + self(tail)
+  },
+  [memoize]
+)
 
-const sum = recursive(self => ([head = 0, ...tail]) => {
-  return tail.length === 0
-    ? head
-    : head + self(tail)
-}, middlewares)
+const sumMemoized = withMiddlewares([log], sum)
 
-const value = sum([1, 2, 3])
+const value1 = sumMemoized([1, 2, 3])
 
 // third call:
 //  Args = [[3]]
@@ -40,7 +44,13 @@ const value = sum([1, 2, 3])
 //  Args = [[1, 2, 3]]
 //  Result = 6
 
-console.log(value) // => 6
+console.log(value1) // => 6
+
+const value2 = sumMemoized([2, 3])
+
+// don't print nothing
+
+console.log(value2) // => 5
 ```
 
 [build-badge]: https://img.shields.io/travis/user/repo/master.png?style=flat-square

src/index.js

@@ -1 +1,34 @@
-export { default as recursive } from './recursive'
+import compose from './compose'
+
+const METADATA = Symbol('recursive-func@METADATA')
+
+const applyMiddlewares = (middlewares, func) => (
+  middlewares.length !== 0
+    ? compose(middlewares)(func)
+    : func
+)
+
+const unwrapMetadata = func => func[METADATA]
+
+export const recursive = (func, middlewares = []) => {
+  const wrapper = applyMiddlewares(
+    middlewares,
+    func((...args) => wrapper(...args))
+  )
+
+  return Object.assign(wrapper, {
+    [METADATA]: {
+      func,
+      middlewares,
+    }
+  })
+}
+
+export const withMiddlewares = (middlewares, wrapper) => {
+  const metadata = unwrapMetadata(wrapper)
+
+  return recursive(metadata.func, [
+    ...metadata.middlewares,
+    ...middlewares,
+  ])
+}

src/recursive.js

@@ -1,6 +1,6 @@
 import expect, { createSpy } from 'expect'
 
-import { recursive } from 'src/index'
+import { recursive, withMiddlewares } from 'src/index'
 
 describe('recursive', () => {
   let id
@@ -75,6 +75,51 @@ describe('recursive', () => {
     })
   })
 
+  describe('withMiddlewares([M2], recursive(F, [M1])) == recursive(F, [M1, M2])', () => {
+    let internal
+    let cacheMiddleware
+    let sum1
+    let sum2
+
+    beforeEach(() => {
+      cacheMiddleware = createSpy().andCall(next => {
+        const cache = {}
+
+        return (...args) => {
+          const key = JSON.stringify(args)
+
+          if (!cache[key]) {
+            cache[key] = next(...args)
+          }
+
+          return cache[key]
+        }
+      })
+
+
+      internal = createSpy().andCall((self, [head, ...tail]) => {
+        if (tail.length === 0) return head
+        return head + self(tail)
+      })
+
+      sum1 = withMiddlewares(
+        [cacheMiddleware],
+        recursive(self => (...args) => {
+          return internal(self, ...args)
+        }),
+      )
+
+      sum2 = withMiddlewares([], sum1)
+    })
+
+    it('should replay middleware when call withMiddlewares', () => {
+      sum1([1, 2, 3])
+      sum2([1, 2, 3])
+
+      expect(internal.calls.length).toEqual(6)
+    })
+  })
+
   describe('recursive(sum)([1, 2, 3])', () => {
     let internal
     let sum