The word monad can be seen as scary, but you don't particularly need to worry about what it means in the general case in order to use the implementations of
>>= (bind). For example, the list monad, where
>>= is defined as below.
(>>=) :: [a] -> (a -> [a]) -> [a] xs >>= k = join (fmap k xs)
>>=, each element of
xs is passed to
k, which returns a list, and then the lists from each invocation of
k are concatanated back together for the final value. This means that
>>= can be used as an alternative to
map, or be used for local transformations of the list, such as repeating each element.
As a filter
Often you would like to filter a list based on a predicate. This can be done with
>>= as below.
filtered = list >>= \x -> if predicate x then [x] else 
This is equivalent to the below use of
filtered = filter predicate list
As a map
>>= can also be used to map a function over the elements of a list, i.e. end up with a list of the same length, but each element has been passed through another function. An example of this is below.
mapped = list >>= return . mapper
This is equivalent to just using
mapped = map mapper list
As a local transform
The cases where
>>>= shines are those that can't be achieved using a single higher-order function. For example, repeating each element twice in a list.
repeated = list >>= \x -> [x, x]
Should I use
My instinct is to use the least general code that solves the problem you're tackling, and solves it clearly. So while using
>>= for when there isn't a single other function that can do the job is good, using it when
filter would do, while interesting, I would probably avoid.
Your scientists were so preoccupied with whether or not they could, they didn’t stop to think if they should.Ian Malcom, Jurassic Park