Foo.hs

module Foo where

import Control.Monad.IO.Class
import Control.Monad.Trans.Resource
import Data.ByteString (ByteString)
import Data.ByteString.Unsafe
import Data.Functor
import Data.Word8
import Foreign.ForeignPtr
import Foreign.ForeignPtr.Unsafe
import Foreign.Ptr
import Streamly
import System.FilePath
import System.IO

import qualified Data.ByteString as BS
import qualified Streamly.Data.Fold as FL
import qualified Streamly.FileSystem.Handle as FH
import qualified Streamly.Internal.Data.Stream.StreamD.Type as D
import qualified Streamly.Internal.FileSystem.Handle as IFH
import qualified Streamly.Internal.Memory.Array.Types as AI
import qualified Streamly.Internal.Prelude as S
import qualified Streamly.Memory.Array as A
import qualified Streamly.Prelude as S



myFileStream :: MonadIO m => FilePath -> ResIO (SerialT m (A.Array Word8))
myFileStream fp = do
  (_, fh) <- allocate (openFile fp ReadMode) hClose
  pure $ IFH.toChunksWithBufferOf (256*1024) fh


entireFile :: FilePath -> IO ByteString
entireFile fp =
  runResourceT $ (myFileStream fp) >>= \stream ->
    S.fold FL.mconcat stream >>= arrayToByteString


arrayToByteString :: MonadIO m => A.Array Word8 -> m ByteString
arrayToByteString arr
  | A.length arr == 0 = return mempty
arrayToByteString AI.Array {..} =
  liftIO $
  withForeignPtr aStart $ \ptr ->
    unsafePackCStringFinalizer ptr aLen (return ())
  where
    aLen =
      let p = unsafeForeignPtrToPtr aStart
       in aEnd `minusPtr` p