Non-primitive function parameters

The current implementation of memoize doesn’t work correctly with non-primitive function parameters.

E.g. look at this test:

it('should not overwrite non-primitive arguments', next => {
  const cache = Object.create(null)
  let c = memoize((key => key), { cache })

  const key1 = { a: 1 }
  const key2 = { a: 2 }
  c(key1)
  c(key2)

  expect(Object.keys(cache)).to.have.length(2)
  // ... cache is { '[Object object]': { a: 2 } } now

  next()
});

Do you think it would make sense to print a corresponding error message when they try to pass any non-primitive ref as a parameter?

WeakMap could be a solution for this problem (for memory leak also).

cc @stryju

[developit]

yup, all correct and all currently true. Problem is I’ve used this lib quite a bit for things under the assumption only the first argument is the cache key and others are ignored. One such example would be caching GET requests through memoize(fetch) - passing any options object would result in a failing reference equality check for the second argument.

Even with a WeakMap-implemented key setup, the following would be awkward:

m(['a', 'b']) !== m(['a', 'b'])  // seems like it ought to be true, but the arrays aren't referentially equal

[stryju]

to add to this, here’s a list of false-positive cache hits:

m(1) === m('1')
m(NaN) === m('NaN')
m([]) === m([,]) === m('')
m(['1,2', 3]) === m([1, 2, 3]) === m('1,2,3') // and so on
m(false) === m('false')
m(undefined) === m('undefined') === m(window.all) // I know, right?!..
// ... and so on

It would be “OK” assuming this would be used for functions with single-type param

---

on a different note, memoize() will not work properly for functions with more than one param