If one happens to be most comfortable with "do" notation for monads ("What are monads? They are the things for which "do" notation works well."), so monads implicitly being defined in terms of bind (>>=) and return, here are the definitions of map and join, the "other" way of defining monads:

join :: (Monad m) => m (m a) -> m a;

join xs = do { x <- xs ; x }

map :: (Monad m) => (a -> b) -> m a -> m b;

map f xs = do { x <- xs ; return $ f x }

map is identical to liftM and slightly narrower than fmap which requires only the Functor typeclass instead of Monad. This redundancy is one of the motivations for the AMP proposal. Incidentally, map (as defined above) would work as well as the famous Prelude map function which operates only on lists, because a list is a Monad (and a Functor).

Just for completeness, here is bind defined in do notation:

(>>=) xs f = do { x <- xs ; f x }

I sometimes like explicitly using the bind operator instead of do notation because the syntax, specifying xs then f, lines up well with the thought process "first prepare the input xs to a function, then call the function f on it". It also works well for longer chains. For example, the expression xs >>= f >>= g >>= h is equivalent to

do {

x <- xs;

y <- f x;

z <- g y;

h z;

}

but not having to name the intermediate results.

Inspired by the tutorial Monads as containers.