# List functor as a coroutine suspension functor

While most common functors, some of which ship with monad-coroutine, contain only one coroutine resumption, this is no requirement. Here is an example of using the list functor in this role. First, a coroutine:

``` factorize :: Monad m => Integer -> Coroutine [] m [Integer]
factorize n | n < 2 = return []
| otherwise = suspend (map (\k-> liftM (k:) \$ factorize (n `div` k)) (factors n))

factors n = [k | k <- 2..n | n `mod` k = 0]
```

So, the coroutine suspends with a list of resumptions. It's the invoker's choice what to do with the list. For example, we can always choose to resume the first alternative only:

``` runFirstAlternative :: Monad m => Coroutine [] m r -> m r
runFirstAlternative cort = pogoStick head cort

primeFactors :: Integer -> [Integer]
primeFactors n = runFirstAlternative (factorize n)
```

As it happens, the first alternative among the factorize resuptions always gives us the lowest factors, which must be a prime number. So this resumption strategy results in a list of prime factors.

But why pick only one resumption to resume? We could run all the resumptions and collect the results:

``` runAllAlternatives :: Monad m => Coroutine [] m r -> m [r]
runAllAlternatives cort = resume cort
>>= liftM concat . mapM runAllAlternatives

allFactorizations :: Integer -> [[Integer]]
allFactorizations = runAllAlternatives (factorize n)
```

The result of the function allFactorizations is a list of lists of factors of its argument, where the product of every list of factors equals the argument.