module Data.Conduit.Misc where
import Data.Conduit
import Control.Monad
concat :: (Monad m) => Conduit [a] m a
concat = awaitForever (mapM_ yield)
simpleConcatFlush :: (Monad m) => Int -> Conduit [a] m (Flush a)
simpleConcatFlush mx = concatFlush 0 sendf
where
sendf curx ev = do
yield (Chunk ev)
if curx >= (mx 1)
then yield Flush >> return 0
else return (curx+1)
concatFlush :: (Monad m) => b -> (b -> a -> ConduitM [a] (Flush a) m b) -> Conduit [a] m (Flush a)
concatFlush initial foldfunc = concatFlush' initial
where
concatFlush' x = await >>= maybe (return ()) (\input -> if null input
then yield Flush >> concatFlush' initial
else foldM foldfunc x input >>= concatFlush')
concatFlushSum :: (Num n, Ord n, Monad m)
=> (a -> n)
-> n
-> Conduit [a] m (Flush a)
concatFlushSum tolength maxlength = concatFlush 0 foldfunc
where
foldfunc curlength element = do
let nextlength = curlength + elementlength
elementlength = tolength element
if nextlength > maxlength
then do
yield Flush
yield (Chunk element)
return elementlength
else do
yield (Chunk element)
return nextlength
groupFlush :: (Monad m) => Conduit (Flush a) m [a]
groupFlush = grouper []
where
grouper lst = await >>= maybe (unless (null lst) (yield (reverse lst))) (handle lst)
handle lst Flush = do
unless (null lst) (yield (reverse lst))
grouper []
handle lst (Chunk x) = grouper (x:lst)
mchunk :: b -> (a -> b) -> Flush a -> b
mchunk n _ Flush = n
mchunk _ f (Chunk x) = f x
mapFlushMaybe :: (Monad m) => (a -> Maybe b) -> Conduit (Flush a) m (Flush b)
mapFlushMaybe f = awaitForever $ mchunk (yield Flush) (maybe (return ()) (yield . Chunk) . f)