How does this memoize function work?

Question

I am feeling very stupid today. I keep looking at this code, trying to trace it, but I just cannot figure out:

What it's actually meant to do
How it works

As far as I can see, the very first time it's called it's the only time action is the same as callFn. So, the very first time it's run, it creates the stack array. Then I lose it. Action is assigned a function that just adds the passed callback to the stack. Then fn is actually called and based on its result, "action" is set to either callFn (?!?) or to a function that calls the callback... And then, all the calls in the stack are called.

I hate getting lost in code, but this is a little beyond me. Anybody smarter than me able to "get it"?

var memoize = function(fn) {
    var callFn = function(callback) {
        var stack = [callback];

        action = function(callback) {
            stack.push(callback);
        };

        fn(function(err, val) {
            action = err ? callFn : function(callback) {
                callback(null, val);
            };

            while (stack.length) stack.shift()(err, val);
        });
    };

    var action = callFn;

    return function(callback) {
        action(callback);
    };
};

That's a bit cryptic. For reference here is a much easier to read version of a memoize function form underscore.js: http://underscorejs.org/docs/underscore.html#section-60 — Alex Wayne, Feb 08 '13 at 23:14
This function is from https://github.com/gett/mongojs -- now that I understand it, I think it's fantastic! — Merc, Feb 09 '13 at 04:04

score 1 · Accepted Answer · edited May 23 '17 at 11:48

1

It does not only memoize the result of fn, it also ensured that there is only one active call to fn at a time. Every callback that is provided during an active call (when action is that anon function from line 5) is pushed on the stack, and once fn calls back the stack (it's a queue actually) is processed and the result is published to all callbacks.

The confusing "action is set to either callFn or…" happens based on the err condition. This parameter indicates that an error happened and is falsy otherwise. So when fn calls back with an error, the stack is processed as usual but also the action is reset to the original callFn (you remember, it had that value at the beginning as well) so subsequent calls will retry to get a value from fn. If there was no error, the action is just set to a function that always calls back with the result val that came back once.

edited May 23 '17 at 11:48

Community

1
1

answered Feb 08 '13 at 23:33

Bergi

630,263
148
957
1,375

Ahhhhhhhhhhhhhhhh that makes so much sense! It's a function from https://github.com/gett/mongojs -- is this a common pattern, with the "queue" etc.? Reading it now, it really does look immensely smart and neat. Don't you think? Thanks a BILLION for explaining it... – Merc Feb 09 '13 at 04:05
Yes, it's smart. Yet I fear smartness is not too common... Most libraries (mongojs, jQuery.Callback) have abstraction functions for this so you don't have to handle the queues yourself. – Bergi Feb 09 '13 at 11:59

score 0 · Answer 2 · answered Feb 08 '13 at 23:33

Memoization is a technique that uses side-effects to improve -at runtime- the performance of a function without altering its behavior. Roughly speaking, you can do memoization by storing function values that were returned in previous calls, and returning these values in further calls to the function instead of actually calling the function.

How does this memoize function work?

2 Answers2