On Thu, Apr 28, 2011 at 11:39 AM, Dmitry Olshansky
Hello,
does somewhere exist function with type like this - manyToOne :: [Iteratee a m b] -> Iteratee a m [b] ?
I.e. I need to process one input through many Iteratees indepentently in constant space and collect results.
It is similar by type with sequenceM but as far as I understand sequenceM won't use the same input for all Iteratees.
I foresee one problem: what is the leftover of 'manyToOne xs' if each x in xs needs different lengths of input? One possible untested-but-compiling solution: import Control.Monad (liftM) import qualified Data.Enumerator as E manyToOne :: Monad m => [E.Iteratee a m b] -> E.Iteratee a m [b] manyToOne [] = return [] manyToOne xs = E.Iteratee $ mapM E.runIteratee xs >>= go where go (E.Yield b s : xs) = liftM (put b s) (go xs) go (E.Error exc : _) = return $ E.Error exc go (E.Continue f : xs) = return $ E.Continue $ go' (E.Continue f : xs) go [] = return $ E.Yield [] (error "manyToOne: never here") go' xs stream = manyToOne $ map apply xs where apply (E.Continue f) = f stream apply step = E.returnI step put b s (E.Yield bs _) = E.Yield (b : bs) s put b s (E.Error exc) = E.Error exc put b s (E.Continue f) = E.Continue (liftM (b:) . f) -- When 'go xs' is a E.Continue, then we just put 'b' on -- the list and let the next round of iteratees decide -- what the leftover will be. HTH, -- Felipe.