Reusable deferreds and promises: Deferreds are by definition not reusable. But if you want to create chainable callbacks that can be reused, this might be an option.

reusable.deferred.js

ReusableDeferred = (function(){
  function defer() {
		var deferred = (function(){
			var self = {
				d: {
					savedSuccesses: [], //used to cache responses if needed
					savedErrors: []
				}
			};
			function resolveSuccesses() {
				if(self.d.success) {
					while(self.d.savedSuccesses.length){
						self.d.success.apply(null, self.d.savedSuccesses.shift());
					}
				}
			}
			function resolveErrors() {
				if(self.d.error) {
					while(self.d.savedErrors.length){
						self.d.error.apply(null, self.d.savedErrors.shift());
					}
				}
			}
			var api = {
				resolve: function() {
					if (self.d){
						self.d.savedSuccesses.push(Array.prototype.slice.call(arguments,0));
						resolveSuccesses();
					}
				},
				reject: function() {
					if (self.d){
						self.d.savedErrors.push(Array.prototype.slice.call(arguments,0));
						resolveErrors();
					}
				},
				promise: {
					then: function(successFn, errorFn) {
						if (self.d) {
							self.d.success = successFn;
							self.d.error = errorFn;
						}
						// if anything was resolved/rejected before the callbacks were applied, resolve/reject them.
						if (self.d.savedSuccesses.length || self.d.savedErrors.length) {
							resolveSuccesses();
							resolveErrors();
						}
						return api.promise;
					},
					cancel: function() {
						delete self.d;
					}
				}
			};
			return api;
		})();
		return deferred;
	}
	return {
		defer: defer
	};
})();