feat(memoizeWithP): Add module memoizeWithP

Memoizes a promise returning/async functions result during consecutive calls with same args. Returns
a promise, even from cache.

src/__tests__/memoizeWithP.js

@@ -0,0 +1,13 @@
+import memoizeWithP from '../memoizeWithP';
+
+describe('Core.memoizeWithP', () => {
+  const memoP = memoizeWithP((...args) => args.join(''));
+
+  test('memoizes an async functions result', async () => {
+    const asyncGetArr = jest.fn(async (a, b) => [a, b]);
+    const memGetArr = memoP(asyncGetArr);
+
+    expect(await memGetArr(1, 2)).toBe(await memGetArr(1, 2));
+    expect(asyncGetArr).toHaveBeenCalledTimes(1);
+  });
+});

src/index.js

@@ -46,6 +46,7 @@ import map from './map';
 import mean from './mean';
 import median from './median';
 import memoizeWith from './memoizeWith';
+import memoizeWithP from './memoizeWithP';
 import modulo from './modulo';
 import multiply from './multiply';
 import negate from './negate';
@@ -123,6 +124,7 @@ export {
   mean,
   median,
   memoizeWith,
+  memoizeWithP,
   modulo,
   multiply,
   negate,

src/memoizeWithP.js

@@ -0,0 +1,25 @@
+import has from './has';
+import prop from './prop';
+
+const memoizeWithP = keyFn => asyncFn => {
+  const cache = {};
+  const isCached = key => has(key, cache);
+  const updateCache = (key, val) => {
+    cache[key] = val;
+  };
+  const getKey = key => new Promise(resolve => resolve(prop(key, cache)));
+
+  return (...args) => {
+    const key = keyFn(...args);
+    if (!isCached(key)) {
+      return asyncFn(...args).then(val => {
+        updateCache(key, val);
+        return val;
+      });
+    }
+
+    return getKey(key);
+  };
+};
+
+export { memoizeWithP as default };