JavaScript deferreds are almost monads

When I was learning monad concept from functional programming I suddenly realized that deferred objects avaiable in some JavaScript libraries (for example in Dojo - http://livedocs.dojotoolkit.org/dojo/Deferred) are strikingly similar to monads.
Haskel has the clearest definition of the monads so let's start from it (don't get scarried, I'll explain essentials later):

class  Monad m  where
     (>>=)            :: m a -> (a -> m b) -> m b
     (>>)             :: m a -> m b -> m b
     return           :: a -> m a
     fail             :: String -> m a

In short words monad is a container type that aims to facilitate operations chaining. The key point is here (other lines either prepare data for it or provide syntatcic sugar):

(>>=)            :: m a -> (a -> m b) -> m b

It defines signature of operator >>=. It takes two arguments: 'm a' (data of type 'a' wrapped into monad of type 'm') and 'a -> m b' (function that takes data of type 'a' and returns data of type 'b' wrapped into monad 'm'). And this operator returns 'm b' (data of type 'b' wrapped into monad of type 'm'). With such operation defined we can build a chain of dependent calculations without calling them immediately. What is even more important is that operations which stands earlier in the chain can abort calculation if it wants. For example, we can use monad Maybe to indicate that data wasn't found. Then with properly defined functions we could write something like this:

(getCountryData "Country") >>= (getRegionData "Region") >>= (getCityData "City")

If country wasn't found then getRegionData and getCityData will not be called - a 'Nothing' instance would be returned immediately. Now let's see what Deferred object from Dojo gives us (the same more or less applies to jQuery.Deferred). It has method 'then' which accepts two functions - success handler and failure handler. Deferred object can be resolved (that means success) or rejected (that means failure). On resolving/rejecting some value may be provided which is passes as argument to appropriate handler. Handler can return another deferred if he wants. And the key point here is that 'then' method of deferred object also returns a deferred object - either original or replaced by previous handlers. That gives us ability to chain handlers and abort computations if necessary. Let's imagine how the same example would look in JavaScript:

dojo.xhrGet({url: "server?country=Country"}).then( 
  function(countryData) {return dojo.xhrGet({url: "server?region=Region"});}).then(
  function(regionData) {return dojo.xhrGet({url: "server?city=City"});}).then(
  function(cityData) { ...process city data here...});

Calls to dojo.xhrGet return deferred objects which are resolved on successful complete of HTTP request or rejected on HTTP request failure. Each handler receives data from previous steps. And each deferred object can terminate the whole workflow if it can't retrieve the data.

Let's recap similarities: