1a934e1 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Use byteLength instead of length in putChunk

1a934e1Harendra Kumar5 years ago

src/Streamly/Internal/FileSystem/File.hs+6−7

compare with master

unifiedsplit

@@ -88,7 +88,6 @@ where

88import Control.Monad.Catch (MonadCatch)

89import Control.Monad.IO.Class (MonadIO(..))

90import Data.Word (Word8)

91−import Foreign.Storable (Storable(..))

92import System.IO (Handle, openFile, IOMode(..), hClose)

91import System.IO (Handle, openFile, IOMode(..), hClose)

93import Prelude hiding (read)

92import Prelude hiding (read)

@@ -198,14 +197,14 @@ usingFile3 = UF.bracket before after

198--

197--

199-- @since 0.7.0

198-- @since 0.7.0

200{-# INLINABLE putChunk #-}

199{-# INLINABLE putChunk #-}

201−putChunk :: Storable a => FilePath -> Array a -> IO ()

200+putChunk :: FilePath -> Array a -> IO ()

202putChunk file arr = SIO.withFile file WriteMode (`FH.putChunk` arr)

201putChunk file arr = SIO.withFile file WriteMode (`FH.putChunk` arr)

203

202

204-- | append an array to a file.

203-- | append an array to a file.

205--

204--

206-- @since 0.7.0

205-- @since 0.7.0

207{-# INLINABLE appendArray #-}

206{-# INLINABLE appendArray #-}

208−appendArray :: Storable a => FilePath -> Array a -> IO ()

207+appendArray :: FilePath -> Array a -> IO ()

209appendArray file arr = SIO.withFile file AppendMode (`FH.putChunk` arr)

208appendArray file arr = SIO.withFile file AppendMode (`FH.putChunk` arr)

210

209

211-------------------------------------------------------------------------------

210-------------------------------------------------------------------------------

@@ -322,7 +321,7 @@ readShared = undefined

322-------------------------------------------------------------------------------

321-------------------------------------------------------------------------------

323

322

324{-# INLINE fromChunksMode #-}

323{-# INLINE fromChunksMode #-}

325−fromChunksMode :: (MonadAsync m, MonadCatch m, Storable a)

324+fromChunksMode :: (MonadAsync m, MonadCatch m)

326 => IOMode -> FilePath -> SerialT m (Array a) -> m ()

325 => IOMode -> FilePath -> SerialT m (Array a) -> m ()

327fromChunksMode mode file xs = S.drain $

326fromChunksMode mode file xs = S.drain $

328 withFile file mode (\h -> S.mapM (FH.putChunk h) xs)

327 withFile file mode (\h -> S.mapM (FH.putChunk h) xs)

@@ -331,7 +330,7 @@ fromChunksMode mode file xs = S.drain $

331--

330--

332-- @since 0.7.0

331-- @since 0.7.0

333{-# INLINE fromChunks #-}

332{-# INLINE fromChunks #-}

334−fromChunks :: (MonadAsync m, MonadCatch m, Storable a)

333+fromChunks :: (MonadAsync m, MonadCatch m)

335 => FilePath -> SerialT m (Array a) -> m ()

334 => FilePath -> SerialT m (Array a) -> m ()

336fromChunks = fromChunksMode WriteMode

335fromChunks = fromChunksMode WriteMode

337

336

@@ -376,7 +375,7 @@ write = toHandleWith A.defaultChunkSize

376--

375--

377-- /Pre-release/

376-- /Pre-release/

378{-# INLINE writeChunks #-}

377{-# INLINE writeChunks #-}

379−writeChunks :: (MonadIO m, MonadCatch m, Storable a)

378+writeChunks :: (MonadIO m, MonadCatch m)

380 => FilePath -> Fold m (Array a) ()

379 => FilePath -> Fold m (Array a) ()

381writeChunks path = Fold step initial extract

380writeChunks path = Fold step initial extract

382 where

381 where

@@ -422,7 +421,7 @@ write = writeWithBufferOf defaultChunkSize

422--

421--

423-- @since 0.7.0

422-- @since 0.7.0

424{-# INLINE appendChunks #-}

423{-# INLINE appendChunks #-}

425−appendChunks :: (MonadAsync m, MonadCatch m, Storable a)

424+appendChunks :: (MonadAsync m, MonadCatch m)

426 => FilePath -> SerialT m (Array a) -> m ()

425 => FilePath -> SerialT m (Array a) -> m ()

427appendChunks = fromChunksMode AppendMode

426appendChunks = fromChunksMode AppendMode

428

427

src/Streamly/Internal/FileSystem/Handle.hs+5−6

@@ -396,8 +396,8 @@ toBytes = AS.concat . toChunks

396--

397-- @since 0.8.1

398{-# INLINABLE putChunk #-}

399−putChunk :: (MonadIO m, Storable a) => Handle -> Array a -> m ()

399+putChunk :: MonadIO m => Handle -> Array a -> m ()

400−putChunk _ arr | A.length arr == 0 = return ()

400+putChunk _ arr | byteLength arr == 0 = return ()

401putChunk h Array{..} =

402 liftIO $ hPutBuf h arrStart aLen >> touch arrContents

403

@@ -420,8 +420,7 @@ putChunk h Array{..} =

420--

421-- @since 0.7.0

422{-# INLINE putChunks #-}

423−putChunks :: (MonadIO m, Storable a)

424− => Handle -> SerialT m (Array a) -> m ()

423+putChunks :: MonadIO m => Handle -> SerialT m (Array a) -> m ()

425putChunks h = S.mapM_ (putChunk h)

424putChunks h = S.mapM_ (putChunk h)

426

425

427-- XXX AS.compact can be written idiomatically in terms of foldMany, just like

426-- XXX AS.compact can be written idiomatically in terms of foldMany, just like

@@ -471,14 +470,14 @@ putBytes = putBytesWithBufferOf defaultChunkSize

471--

470--

472-- @since 0.7.0

471-- @since 0.7.0

473{-# INLINE writeChunks #-}

472{-# INLINE writeChunks #-}

474−writeChunks :: (MonadIO m, Storable a) => Handle -> Fold m (Array a) ()

473+writeChunks :: MonadIO m => Handle -> Fold m (Array a) ()

475writeChunks h = FL.drainBy (putChunk h)

474writeChunks h = FL.drainBy (putChunk h)

476

475

477-- | Like writeChunks but uses the experimental 'Refold' API.

476-- | Like writeChunks but uses the experimental 'Refold' API.

478--

477--

479-- /Internal/

478-- /Internal/

480{-# INLINE consumeChunks #-}

479{-# INLINE consumeChunks #-}

481−consumeChunks :: (MonadIO m, Storable a) => Refold m Handle (Array a) ()

480+consumeChunks :: MonadIO m => Refold m Handle (Array a) ()

482consumeChunks = Refold.drainBy putChunk

481consumeChunks = Refold.drainBy putChunk

483

482

484-- XXX lpackArraysChunksOf should be written idiomatically

483-- XXX lpackArraysChunksOf should be written idiomatically