function all_async(values, iter_callback, done_callback)
    {
        var remaining = values.length;

        if (remaining === 0) {
            done_callback();
        }

        forEach(values,
                function(element) {
                    var invoked = false;
                    var elDone = function() {
                        if (invoked) {
                            return;
                        }

                        invoked = true;
                        remaining -= 1;

                        if (remaining === 0) {
                            done_callback();
                        }
                    };

                    iter_callback(element, elDone);
                });
    }
Immediately invoke a "iteratee" function with a series of values in
parallel and invoke a final "done" function when all of the "iteratee"
invocations have signaled completion.

If all callbacks complete synchronously (or if no callbacks are
specified), the ``done_callback`` will be invoked synchronously. It is the
responsibility of the caller to ensure asynchronicity in cases where
that is desired.

@param {array} value Zero or more values to use in the invocation of
                     ``iter_callback``
@param {function} iter_callback A function that will be invoked
                                once for each of the values min
                                ``value``. Two arguments will
                                be available in each
                                invocation: the value from
                                ``value`` and a function that
                                must be invoked to signal
                                completion
@param {function} done_callback A function that will be invoked after
                                all operations initiated by the
                                ``iter_callback`` function have signaled
                                completion