JavaScript function (constructor) that emulates a simple version of promises

waiter.js

var Waiter = (function () {
    "use strict";

    var F, func, handleDone, slice;

    F = function () { return undefined; };

    func = function () {
        var me, resolveArgs, done, waiters;

        me = this;
        resolveArgs = [];
        done = false;
        waiters = [];

        me.resolve = function () {
            if (!done) {
                done = true;
                resolveArgs = slice(arguments);
                handleDone(waiters, resolveArgs);
            }
            return me;
        };

        me.done = function (callback) {
            if (done) {
                handleDone([callback], resolveArgs);
            } else {
                waiters.push(callback);
            }
            return me;
        };

        me.isDone = function () {
            return done;
        };
    };

    handleDone = function (waitArr, args) {
        var i, j, cur;
        for (i = 0, j = waitArr.length; i < j; i++) {
            cur = waitArr[i];
            F.apply.call(cur, null, args);
        }
    };

    func.when = function () {
        var newWaiter, counter, targetLen, checker, i, j, curWaiter;

        newWaiter = new Waiter();
        counter = 0;
        targetLen = arguments.length;
        checker = function () {
            if (++counter === targetLen) {
                newWaiter.resolve();
            }
        };

        for (i = 0, j = arguments.length; i < j; i++) {
            curWaiter = arguments[i];
            curWaiter.done(checker);
        }

        return newWaiter;
    };

    slice = function (arr, start, howMany) {
        var stop, newArr, i, j, cur;

        start = +start || 0;
        howMany = +howMany || Infinity;
        stop = Math.min(start + howMany, arr.length);
        newArr = [];
        for (i = start, j = stop; i < j; i++) {
            cur = arr[i];
            newArr.push(cur);
        }

        return newArr;
    };

    return func;
}());