{-# LANGUAGE CPP #-}
module Streamly.External.ByteString.Lazy
( chunkReader
, reader
, toChunks
, fromChunks
, fromChunksIO
, read
, readChunks
)
where
import Data.Word (Word8)
import Streamly.Data.Array (Array)
import System.IO.Unsafe (unsafeInterleaveIO)
import Streamly.Data.Stream (Stream)
import Data.ByteString.Lazy.Internal (ByteString(..), chunk)
#if MIN_VERSION_streamly_core(0,2,0)
import Streamly.Internal.Data.Unfold (Unfold(..))
import Streamly.Internal.Data.Stream (Step(..))
#else
import Streamly.Internal.Data.Unfold.Type (Unfold(..))
import Streamly.Internal.Data.Stream.StreamD.Type (Step(..))
#endif
import qualified Streamly.External.ByteString as Strict
import qualified Streamly.Data.Array as Array
import qualified Streamly.Data.Unfold as Unfold
import qualified Streamly.Data.Stream as Stream
import Prelude hiding (read)
{-# INLINE chunkReader #-}
chunkReader :: Monad m => Unfold m ByteString (Array Word8)
chunkReader :: forall (m :: * -> *). Monad m => Unfold m ByteString (Array Word8)
chunkReader = forall (m :: * -> *) a b s.
(s -> m (Step s b)) -> (a -> m s) -> Unfold m a b
Unfold forall {m :: * -> *}.
Monad m =>
ByteString -> m (Step ByteString (Array Word8))
step forall {a}. a -> m a
seed
where
seed :: a -> m a
seed = forall (m :: * -> *) a. Monad m => a -> m a
return
step :: ByteString -> m (Step ByteString (Array Word8))
step (Chunk ByteString
bs ByteString
bl) = forall (m :: * -> *) a. Monad m => a -> m a
return forall a b. (a -> b) -> a -> b
$ forall s a. a -> s -> Step s a
Yield (ByteString -> Array Word8
Strict.toArray ByteString
bs) ByteString
bl
step ByteString
Empty = forall (m :: * -> *) a. Monad m => a -> m a
return forall s a. Step s a
Stop
{-# INLINE reader #-}
reader :: Monad m => Unfold m ByteString Word8
reader :: forall (m :: * -> *). Monad m => Unfold m ByteString Word8
reader = forall (m :: * -> *) b c a.
Monad m =>
Unfold m b c -> Unfold m a b -> Unfold m a c
Unfold.many forall (m :: * -> *) a. (Monad m, Unbox a) => Unfold m (Array a) a
Array.reader forall (m :: * -> *). Monad m => Unfold m ByteString (Array Word8)
readChunks
{-# INLINE toChunks #-}
toChunks :: Monad m => ByteString -> Stream m (Array Word8)
toChunks :: forall (m :: * -> *).
Monad m =>
ByteString -> Stream m (Array Word8)
toChunks = forall (m :: * -> *) a b.
Applicative m =>
Unfold m a b -> a -> Stream m b
Stream.unfold forall (m :: * -> *). Monad m => Unfold m ByteString (Array Word8)
readChunks
{-# INLINE fromChunks #-}
fromChunks :: Monad m => Stream m (Array Word8) -> m ByteString
fromChunks :: forall (m :: * -> *).
Monad m =>
Stream m (Array Word8) -> m ByteString
fromChunks = forall (m :: * -> *) a b.
Monad m =>
(a -> b -> b) -> b -> Stream m a -> m b
Stream.foldr ByteString -> ByteString -> ByteString
chunk ByteString
Empty forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Array Word8 -> ByteString
Strict.fromArray
{-# INLINE fromChunksIO #-}
fromChunksIO :: Stream IO (Array Word8) -> IO ByteString
fromChunksIO :: Stream IO (Array Word8) -> IO ByteString
fromChunksIO =
forall (m :: * -> *) a b.
Monad m =>
(a -> m b -> m b) -> m b -> Stream m a -> m b
Stream.foldrM (\ByteString
x IO ByteString
b -> ByteString -> ByteString -> ByteString
chunk ByteString
x forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
<$> forall a. IO a -> IO a
unsafeInterleaveIO IO ByteString
b) (forall (f :: * -> *) a. Applicative f => a -> f a
pure ByteString
Empty)
forall b c a. (b -> c) -> (a -> b) -> a -> c
. forall (f :: * -> *) a b. Functor f => (a -> b) -> f a -> f b
fmap Array Word8 -> ByteString
Strict.fromArray
{-# DEPRECATED readChunks "Please use chunkReader instead." #-}
{-# INLINE readChunks #-}
readChunks :: Monad m => Unfold m ByteString (Array Word8)
readChunks :: forall (m :: * -> *). Monad m => Unfold m ByteString (Array Word8)
readChunks = forall (m :: * -> *). Monad m => Unfold m ByteString (Array Word8)
chunkReader
{-# DEPRECATED read "Please use reader instead." #-}
{-# INLINE read #-}
read :: Monad m => Unfold m ByteString Word8
read :: forall (m :: * -> *). Monad m => Unfold m ByteString Word8
read = forall (m :: * -> *). Monad m => Unfold m ByteString Word8
reader