module System.IO.Streams.Lazy where
import Prelude hiding (read)
import qualified Data.ByteString as BS
import qualified Data.ByteString.Lazy as BL
import System.IO.Streams (InputStream, OutputStream, read)
import System.IO.Streams.Concurrent (makeChanPipe)
import System.IO.Unsafe (unsafeInterleaveIO)
toLazyList :: InputStream a -> IO [a]
toLazyList is = unsafeInterleaveIO $ do
ma <- read is
case ma of
Nothing -> return []
Just a -> do
as <- toLazyList is
return (a : as)
lazyListOutput :: IO (OutputStream a, [a])
lazyListOutput = do
(is, os) <- makeChanPipe
as <- toLazyList is
return (os, as)
toLazyByteString :: InputStream BS.ByteString -> IO BL.ByteString
toLazyByteString is = BL.fromChunks <$> toLazyList is
lazyByteStringOutput :: IO (OutputStream BS.ByteString, BL.ByteString)
lazyByteStringOutput = do
(os, ll) <- lazyListOutput
return (os, BL.fromChunks ll)