Add support for reusing a recent value if resultEqualityCheck given

Author: markerikson

src/defaultMemoize.ts

@@ -11,6 +11,7 @@ interface Entry {
 interface Cache {
   get(key: any): Entry | undefined
   put(key: any, value: any): void
+  getValues(): any[]
 }
 
 function createSingletonCache(equals: EqualityFn): Cache {
@@ -24,6 +25,10 @@ function createSingletonCache(equals: EqualityFn): Cache {
 
     put(key: any, value: any) {
       entry = { key, value }
+    },
+
+    getValues() {
+      return entry ? [entry.value] : []
     }
   }
 }
@@ -61,14 +66,18 @@ function createLruCache(maxSize: number, equals: EqualityFn): Cache {
     }
   }
 
-  return { get, put }
+  function getValues() {
+    return entries.map(entry => entry.value)
+  }
+
+  return { get, put, getValues }
 }
 
 export const defaultEqualityCheck: EqualityFn = (a, b): boolean => {
   return a === b
 }
 
-function createCacheKeyComparator(equalityCheck: EqualityFn) {
+export function createCacheKeyComparator(equalityCheck: EqualityFn) {
   return function areArgumentsShallowlyEqual(
     prev: unknown[] | IArguments | null,
     next: unknown[] | IArguments | null
@@ -95,8 +104,8 @@ export interface DefaultMemoizeOptions {
   maxSize?: number
 }
 
-// defaultMemoize now supports a configurable cache size and comparison of the result value.
-// Updated behavior based on the `betterMemoize` function from
+// defaultMemoize now supports a configurable cache size with LRU behavior,
+// and optional comparison of the result value with existing values
 export function defaultMemoize<F extends (...args: any[]) => any>(
   func: F,
   equalityCheckOrOptions?: EqualityFn | DefaultMemoizeOptions
@@ -113,9 +122,6 @@ export function defaultMemoize<F extends (...args: any[]) => any>(
   } = providedOptions
 
   const comparator = createCacheKeyComparator(equalityCheck)
-  let resultComparator = resultEqualityCheck
-    ? createCacheKeyComparator(resultEqualityCheck)
-    : undefined
 
   const cache =
     maxSize === 1
@@ -128,6 +134,17 @@ export function defaultMemoize<F extends (...args: any[]) => any>(
     if (value === undefined) {
       // @ts-ignore
       value = func.apply(null, arguments)
+
+      if (resultEqualityCheck) {
+        const existingValues = cache.getValues()
+        const matchingValue = existingValues.find(ev =>
+          resultEqualityCheck(ev, value)
+        )
+        if (matchingValue) {
+          return matchingValue
+        }
+      }
+
       cache.put(arguments, value)
     }
     return value

test/test_selector.ts

@@ -513,6 +513,82 @@ describe('defaultMemoize', () => {
     expect(funcCalls).toBe(7)
   })
 
+  test('Allows reusing an existing result if they are equivalent', () => {
+    interface Todo {
+      id: number
+      name: string
+    }
+
+    const todos1: Todo[] = [
+      { id: 1, name: 'a' },
+      { id: 2, name: 'b' },
+      { id: 3, name: 'c' }
+    ]
+    const todos2 = todos1.slice()
+    todos2[2] = { id: 3, name: 'd' }
+
+    function is(x: unknown, y: unknown) {
+      if (x === y) {
+        return x !== 0 || y !== 0 || 1 / x === 1 / y
+      } else {
+        return x !== x && y !== y
+      }
+    }
+
+    function shallowEqual(objA: any, objB: any) {
+      if (is(objA, objB)) return true
+
+      if (
+        typeof objA !== 'object' ||
+        objA === null ||
+        typeof objB !== 'object' ||
+        objB === null
+      ) {
+        return false
+      }
+
+      const keysA = Object.keys(objA)
+      const keysB = Object.keys(objB)
+
+      if (keysA.length !== keysB.length) return false
+
+      for (let i = 0; i < keysA.length; i++) {
+        if (
+          !Object.prototype.hasOwnProperty.call(objB, keysA[i]) ||
+          !is(objA[keysA[i]], objB[keysA[i]])
+        ) {
+          return false
+        }
+      }
+
+      return true
+    }
+
+    for (let maxSize of [1, 3]) {
+      let funcCalls = 0
+
+      const memoizer = defaultMemoize(
+        (state: Todo[]) => {
+          funcCalls++
+          return state.map(todo => todo.id)
+        },
+        {
+          maxSize,
+          resultEqualityCheck: shallowEqual
+        }
+      )
+
+      const ids1 = memoizer(todos1)
+      expect(funcCalls).toBe(1)
+
+      const ids2 = memoizer(todos1)
+      expect(funcCalls).toBe(1)
+      expect(ids2).toBe(ids1)
+
+      const ids3 = memoizer(todos2)
+      expect(funcCalls).toBe(2)
+      expect(ids3).toBe(ids1)
+    }
   })
 
   test('Accepts an options object as an arg', () => {