ByteString.hs

{-# LANGUAGE RankNTypes #-}
{-# LANGUAGE GeneralizedNewtypeDeriving #-}

module Pipes.Transduce.ByteString (
        -- * Collecting  input
        intoLazyBytes
        -- * Reading from handles
    ,   drainHandle
    ,   drainHandleFallibly
    ,   ChunkSize
    ,   chunkSize
    ,   chunkSizeDefault
    ) where

import Prelude hiding (lines)
import Data.Bifunctor
import Data.Monoid
import Data.Void
import Data.Foldable
import Data.ByteString
import qualified Data.ByteString.Lazy
import Data.Text hiding (lines)
import Data.Text.Encoding.Error (UnicodeException(..))
import Control.Applicative
import Control.Applicative.Lift
import Control.Monad
import Control.Monad.Trans.Except
import Control.Monad.Trans.Free hiding (Pure)
import qualified Control.Foldl as Foldl
import Control.Exception
import Pipes 
import qualified Pipes.Text
import Pipes.Text.Encoding (decodeUtf8) 
import Pipes.Lift (distribute) 
--import Pipes.Prelude
import qualified Pipes.ByteString (hGetSome)
import qualified Pipes.Prelude as Pipes
import qualified Pipes.Group as Pipes
import qualified Pipes.Parse
import qualified Pipes.Text
import qualified Data.Text.Lazy
import Pipes.Concurrent
import Lens.Family (view)
import System.IO
import Data.ByteString.Lazy.Internal (defaultChunkSize)

import Pipes.Transduce

{- $setup
>>> :set -XOverloadedStrings
>>> import Control.Applicative
>>> import Control.Monad
>>> import qualified Pipes.Transduce as PT
-}

{-| 
    Collect strict 'ByteString's into a lazy 'ByteString'.

>>> PT.fold intoLazyBytes (mapM_ yield ["aa","bb","cc"]) 
("aabbcc",())

-}
intoLazyBytes :: Fold' ByteString e Data.ByteString.Lazy.ByteString
intoLazyBytes = fmap Data.ByteString.Lazy.fromChunks (withFold Foldl.list)

drainHandleFallibly 
    :: Fold' ByteString e r 
    -> ChunkSize 
    -> Handle 
    -> IO (Either e r) 
drainHandleFallibly somefold (ChunkSize csize) handle =
    fmap (bimap id fst) (Pipes.Transduce.foldFallibly somefold (Pipes.ByteString.hGetSome csize handle))

drainHandle
    :: Fold' ByteString Void r 
    -> ChunkSize  
    -> Handle 
    -> IO r
drainHandle somefold (ChunkSize csize) handle =
    fmap fst (Pipes.Transduce.fold somefold (Pipes.ByteString.hGetSome csize handle))

{-| Maximum chunk size      
-}
newtype ChunkSize = ChunkSize Int deriving (Show,Eq,Ord,Num)

chunkSize :: Int -> ChunkSize
chunkSize = ChunkSize

chunkSizeDefault :: ChunkSize
chunkSizeDefault = chunkSize defaultChunkSize