Basic rough for implementing a Deferred process.

## deferred.js
/*
 * referenced jQuery's Deferred pattern
*/

(function(window, undefined){

    window.when = function()
    {
        var _int = function(a)
        {
            this.success        = function(){};
            this.failure        = function(){};
            this.dependents     = [];
            this.count          = 0;
            this.fire           = 0;
            this.stop           = false;

            var deferreddata = [].slice.call(a,0);

            for( var i=0; i < deferreddata.length; i++ )
            {
                this.count += 1;

                if( !deferreddata[i].promise )
                {
                    deferreddata[i] = {value:deferreddata[i]};
                }

                deferreddata[i].when = this;
                this.dependents.push( deferreddata[i] );
            }
        };

        _int.prototype.then = function(s, f)
        {
            var istype = function(o)
            {
                return {}.toString.call(o).match(/\s([a-z|A-Z]+)/)[1].toLowerCase();
            };

            if(istype(s) == "function")
            {
                this.success = s;
            }

            if(istype(f) == "function")
            {
                this.failure = f;
            }

            for( var i=0; i < this.dependents.length; i++ )
            {
                if( this.dependents[i].value )
                {
                    process.call(this.dependents[i], this.dependents[i].value, 1);
                }
            }
        };

        return new _int(arguments);
    }


    window.deferred = function()
    {
        var _int = function(a){};

        _int.prototype.promise = function()
        {
            return this;
        };

        _int.prototype.resolve = function(v)
        {
            if(!this.when.stop)
            {
                process.call(this, v);
            }
        };

        _int.prototype.error = function(v)
        {
            this.fail = true;
            process.call(this, v);
        };

        _int.prototype.cancel = function()
        {
            this.when.stop = true;
        };

        return new _int(arguments);
    }


    function process(v)
    {
        this.value = v;

        var howmany         = this.when.count,
            howmanyfired    = (this.when.fire += 1),
            dependents      = this.when.dependents,
            callback        = (this.fail)? this.when.failure : this.when.success;

        if( this.fail )
        {
            this.when.stop = true;
        }

        if(howmany == howmanyfired || this.fail)
        {
            var temp = [];

            for( var i=0; i < dependents.length; i++ )
            {
                temp.push(dependents[i].value);

                if( this.fail && this===dependents[i] )
                {
                    break;
                }
            }

            callback.apply(this, temp);
        }
    }

})(this);

## demo.html
<!doctype html>
<html>
    <head>
        <meta charset="utf-8" />
        <title>JS.Deferred</title>
    </head>
    <body>

        <div>
<!-- Begin Body - - - - - - - - - - - - - - - - - - - - - - - - - - -->
            <h1>JS.Deferred</h1>

            <p>
                Sets out a rough Deferred pattern.
            </p>

<!-- End Body - - - - - - - - - - - - - - - - - - - - - - - - - - -->
        </div>


        <script src="deferred.js"></script>

        <script>

(function(window, undefined){


    //-- use deferred
    when( DelayFunc1("one", 5000), DelayFunc2("two", 7000), "three" )
        .then(function( one, two, three )
        {
            console.log("success one = " + Array.prototype.join.call(arguments,","));
        },
        function( one, two, three )
        {
            console.log("error one = " + Array.prototype.join.call(arguments,","));
        });

    //-- no deferred
    when( "one", "two", {"three":true} )
        .then(function( one, two, three )
        {
            console.log("success two = " + Array.prototype.join.call(arguments,","));
        },
        function( one, two, three )
        {
            console.log("error two = " + Array.prototype.slice.call(arguments,","));
        });


    //-- delay resolve
    function DelayFunc1( str, time )
    {
        var def = deferred();

        setTimeout(function()
        {
            def.resolve( "Success-"+str );
        },time);

        return def.promise();
    }

    //-- delay error
    function DelayFunc2( str, time )
    {
        var def = deferred();

        setTimeout(function()
        {
            def.error( "Error-"+str );
        },time);

        return def.promise();
    }

    //--
    function StringFormat()
    {
        var args    = Array.prototype.slice.call(arguments, 0),
            string  = args.shift();

        for(var i=0; i<args.length; i++)
        {
            string = string.replace( new RegExp('\\{'+i+'\\}','g'), args[i]);
        }
        return string;
    }

})();
        </script>
    </body>
</html>