It can map, filter, and locally transform a list

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)
``````

When evaluating `>>=`, 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 `filter`, `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 `filter`.

``````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 `map`.

``````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 `map` or `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