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.