({toString:function(){ return ‘foo’ }}) in ({ foo: ‘bar’ }); // true

Since native Object objects are converted to “[object Object]“, the `memo` function will produce unexpected results:

function memo(f) {
return function () {
var args = Array.prototype.slice.call(arguments);
f.memo = f.memo || {};
return (args in f.memo)
? f.memo[args]
: (f.memo[args] = f.apply(this, args));
};
};

function f(o1, o2) { return o1.x + o2.x };
var m = memo(f);

m({ x: 1 }, { x: 2 }); // 3
m({ x: 2 }, { x: 4 }); // 3 (boom!)

I wouldn’t “work around” this issue (as it would require storing cached values as keys of an array, rather than as keys of an object – to avoid implicit string conversion – crippling complexity from O(1) to O(n) : )), but rather document it as such.

One thing that you didn’t point out in your last example.
Because you overridden the original function, and the fib function calls its self; you will get pre-memoized values.

Example:
var fib = memo(fib);
fib(10); // Calls fib(9) and fib(8) and fib(7) and fib(6) and …
fib(12); // Calls fib(11) and fib(10) <- memoized!!

This way calling for the Fibonacci Sequence on any number, speeds up other calls.

Why not store the memo object in the closure of the anonymous function? That way it’s safe from modification by other code.

You might still want to cache the memoized version of the function, since it doesn’t make sense to memoize a function more than once.

When you use the args array as an object property, it just gets converted into a string again, so you can avoid an extra step by joining the arguments instead of slicing/stringifying them.


function memo(f) {
if (f.memo)
return f.memo;
var cache = {}, join = Array.prototype.join;
return (f.memo = function() {
var key = join.call(arguments);
return (key in cache)
? cache[key]
: cache[key] = f.apply(this, arguments);
});
}


function memo(f) {
f.memo = f.memo || {};
return function (x) {
return (x in f.memo)? f.memo[x] : f.memo[x] = f(x);
};
}