d70bac4 · streamly · git.iko.soy

git.iko.soy/streamly

Merge pull request #447

Cleanup hlint warnings in Streamly.Internal.FileSystem.

commitd70bac43a6ce7af1359b7313af2fdfb088fbc7b2 authorpranaysashank <pranaysashank@gmail.com> dateFri 3 Apr 2020, 16:19 (7 years ago) parentb964c64 97523d9

7 files changed+36−49

compare with master

unifiedsplit

.hlint.yaml+3 src/Streamly/Internal/FileSystem/Dir.hs−4 src/Streamly/Internal/FileSystem/File.hs+5−9 src/Streamly/Internal/FileSystem/Handle.hs+1−4 src/Streamly/Internal/Memory/Array.hs+7−7 src/Streamly/Internal/Memory/Array/Types.hs+20−22 src/Streamly/Internal/Memory/ArrayStream.hs−3

.hlint.yaml+3

@@ -14,6 +14,9 @@

1414- ignore: {name: "Use tuple-section"} # requires GHC extension

1515- ignore: {name: "Use fromMaybe"} # may want to use this suggestion, but it didn't match the common idiom of the library

1616- ignore: {name: "Use unless"} # low power-to-weight

17+- ignore: {name: "Reduce duplication"}

18+- ignore: {name: "Use <>"}

19+- ignore: {name: "Use fewer imports"}

1720

1821

1922# Specify additional command line arguments

src/Streamly/Internal/FileSystem/Dir.hs−4

@@ -1,8 +1,4 @@

11{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

3−{-# LANGUAGE MagicHash #-}

4−{-# LANGUAGE RecordWildCards #-}

5−{-# LANGUAGE UnboxedTuples #-}

73#include "inline.hs"

src/Streamly/Internal/FileSystem/File.hs+5−9

@@ -1,9 +1,5 @@

11{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

32{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE MagicHash #-}

5−{-# LANGUAGE RecordWildCards #-}

6−{-# LANGUAGE UnboxedTuples #-}

84#include "inline.hs"

@@ -180,14 +176,14 @@ usingFile =

180176-- @since 0.7.0

181177{-# INLINABLE writeArray #-}

182178writeArray :: Storable a => FilePath -> Array a -> IO ()

183−writeArray file arr = SIO.withFile file WriteMode (\h -> FH.writeArray h arr)

179+writeArray file arr = SIO.withFile file WriteMode (`FH.writeArray` arr)

184180

185181-- | append an array to a file.

186182--

187183-- @since 0.7.0

188184{-# INLINABLE appendArray #-}

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

190−appendArray file arr = SIO.withFile file AppendMode (\h -> FH.writeArray h arr)

186+appendArray file arr = SIO.withFile file AppendMode (`FH.writeArray` arr)

191187

192188-------------------------------------------------------------------------------

193189-- Stream of Arrays IO

@@ -353,12 +349,12 @@ writeChunks path = Fold step initial extract

353349 initial = do

354350 h <- liftIO (openFile path WriteMode)

355351 fld <- FL.initialize (FH.writeChunks h)

356− `MC.onException` (liftIO $ hClose h)

352+ `MC.onException` liftIO (hClose h)

357353 return (fld, h)

358354 step (fld, h) x = do

359− r <- FL.runStep fld x `MC.onException` (liftIO $ hClose h)

355+ r <- FL.runStep fld x `MC.onException` liftIO (hClose h)

360356 return (r, h)

361− extract ((Fold _ initial1 extract1), h) = do

357+ extract (Fold _ initial1 extract1, h) = do

362358 liftIO $ hClose h

363359 initial1 >>= extract1

364360

src/Streamly/Internal/FileSystem/Handle.hs+1−4

@@ -1,9 +1,6 @@

11{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

32{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE MagicHash #-}

53{-# LANGUAGE RecordWildCards #-}

6−{-# LANGUAGE UnboxedTuples #-}

85#include "inline.hs"

@@ -352,7 +349,7 @@ writeArray h Array{..} = withForeignPtr aStart $ \p -> hPutBuf h p aLen

352349{-# INLINE fromChunks #-}

353350fromChunks :: (MonadIO m, Storable a)

354351 => Handle -> SerialT m (Array a) -> m ()

355−fromChunks h m = S.mapM_ (liftIO . writeArray h) m

352+fromChunks h = S.mapM_ (liftIO . writeArray h)

356353

357354-- | Write a stream of chunks to standard output.

358355--

src/Streamly/Internal/Memory/Array.hs+7−7

@@ -1,7 +1,6 @@

11{-# LANGUAGE BangPatterns #-}

22{-# LANGUAGE CPP #-}

33{-# LANGUAGE MagicHash #-}

4−{-# LANGUAGE RecordWildCards #-}

54{-# LANGUAGE UnboxedTuples #-}

65{-# LANGUAGE ScopedTypeVariables #-}

@@ -129,6 +128,7 @@ module Streamly.Internal.Memory.Array

129128 )

130129where

131130

131+import Control.Monad (when)

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

133133-- import Data.Functor.Identity (Identity)

134134import Foreign.ForeignPtr (withForeignPtr, touchForeignPtr)

@@ -173,7 +173,7 @@ newArray len = undefined

173173{-# INLINE fromStreamN #-}

174174fromStreamN :: (MonadIO m, Storable a) => Int -> SerialT m a -> m (Array a)

175175fromStreamN n m = do

176− if n < 0 then error "writeN: negative write count specified" else return ()

176+ when (n < 0) $ error "writeN: negative write count specified"

177177 A.fromStreamDN n $ D.toStreamD m

178178

179179-- | Create an 'Array' from a stream. This is useful when we want to create a

@@ -230,7 +230,7 @@ read = Unfold step inject

230230 return $ ReadUState (ForeignPtr end contents) (Ptr start)

231231

232232 {-# INLINE_LATE step #-}

233− step (ReadUState fp@(ForeignPtr end _) p) | p == (Ptr end) =

233+ step (ReadUState fp@(ForeignPtr end _) p) | p == Ptr end =

234234 let x = A.unsafeInlineIO $ touchForeignPtr fp

235235 in x `seq` return D.Stop

236236 step (ReadUState fp p) = do

@@ -242,7 +242,7 @@ read = Unfold step inject

242242 -- evaluated/written to before we peek at them.

243243 let !x = A.unsafeInlineIO $ peek p

244244 return $ D.Yield x

245− (ReadUState fp (p `plusPtr` (sizeOf (undefined :: a))))

245+ (ReadUState fp (p `plusPtr` sizeOf (undefined :: a)))

246246

247247-- | Unfold an array into a stream, does not check the end of the array, the

248248-- user is responsible for terminating the stream within the array bounds. For

@@ -274,7 +274,7 @@ unsafeRead = Unfold step inject

274274 r <- peek (Ptr p)

275275 touch contents

276276 return r

277− let !(Ptr p1) = Ptr p `plusPtr` (sizeOf (undefined :: a))

277+ let !(Ptr p1) = Ptr p `plusPtr` sizeOf (undefined :: a)

278278 return $ D.Yield x (ForeignPtr p1 contents)

279279

280280 touch r = IO $ \s -> case touch# r s of s' -> (# s', () #)

@@ -402,7 +402,7 @@ readIndex arr i =

402402 if i < 0 || i > length arr - 1

403403 then Nothing

404404 else A.unsafeInlineIO $

405− withForeignPtr (aStart arr) $ \p -> fmap Just $ peekElemOff p i

405+ withForeignPtr (aStart arr) $ \p -> Just <$> peekElemOff p i

406406

407407{-

408408-- | @readSlice arr i count@ streams a slice of the array @arr@ starting

@@ -500,7 +500,7 @@ streamTransform f arr =

500500-- /Internal/

501501{-# INLINE fold #-}

502502fold :: forall m a b. (MonadIO m, Storable a) => Fold m a b -> Array a -> m b

503−fold f arr = P.runFold f $ (toStream arr :: Serial.SerialT m a)

503+fold f arr = P.runFold f (toStream arr :: Serial.SerialT m a)

504504

505505-- | Fold an array using a stream fold operation.

506506--

src/Streamly/Internal/Memory/Array/Types.hs+20−22

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

8888

8989import Control.Exception (assert)

9090import Control.DeepSeq (NFData(..))

91−import Control.Monad (when)

91+import Control.Monad (when, void)

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

9393import Data.Functor.Identity (runIdentity)

9494#if __GLASGOW_HASKELL__ < 808

@@ -208,7 +208,7 @@ foreign import ccall unsafe "string.h memchr" c_memchr

208208

209209-- XXX we are converting Int to CSize

210210memcpy :: Ptr Word8 -> Ptr Word8 -> Int -> IO ()

211−memcpy dst src len = c_memcpy dst src (fromIntegral len) >> return ()

211+memcpy dst src len = void (c_memcpy dst src (fromIntegral len))

212212

213213foreign import ccall unsafe "string.h memcmp" c_memcmp

214214 :: Ptr Word8 -> Ptr Word8 -> CSize -> IO CInt

@@ -293,16 +293,16 @@ unsafeSnoc arr@Array{..} x = do

293293 error "BUG: unsafeSnoc: writing beyond array bounds"

294294 poke aEnd x

295295 touchForeignPtr aStart

296− return $ arr {aEnd = aEnd `plusPtr` (sizeOf (undefined :: a))}

296+ return $ arr {aEnd = aEnd `plusPtr` sizeOf (undefined :: a)}

297297

298298{-# INLINE snoc #-}

299299snoc :: forall a. Storable a => Array a -> a -> IO (Array a)

300−snoc arr@Array {..} x = do

301− if (aEnd == aBound)

300+snoc arr@Array {..} x =

301+ if aEnd == aBound

302302 then do

303303 let oldStart = unsafeForeignPtrToPtr aStart

304304 size = aEnd `minusPtr` oldStart

305− newSize = (size + (sizeOf (undefined :: a)))

305+ newSize = size + sizeOf (undefined :: a)

306306 newPtr <- Malloc.mallocForeignPtrAlignedBytes

307307 newSize (alignment (undefined :: a))

308308 withForeignPtr newPtr $ \pNew -> do

@@ -317,7 +317,7 @@ snoc arr@Array {..} x = do

317317 else do

318318 poke aEnd x

319319 touchForeignPtr aStart

320− return $ arr {aEnd = aEnd `plusPtr` (sizeOf (undefined :: a))}

320+ return $ arr {aEnd = aEnd `plusPtr` sizeOf (undefined :: a)}

321321

322322-- | Reallocate the array to the specified size in bytes. If the size is less

323323-- than the original array the array gets truncated.

@@ -449,7 +449,7 @@ toStreamD Array{..} =

449449 r <- peek p

450450 touchForeignPtr aStart

451451 return r

452− return $ D.Yield x (p `plusPtr` (sizeOf (undefined :: a)))

452+ return $ D.Yield x (p `plusPtr` sizeOf (undefined :: a))

453453

454454{-# INLINE toStreamK #-}

455455toStreamK :: forall t m a. (K.IsStream t, Storable a) => Array a -> t m a

@@ -466,7 +466,7 @@ toStreamK Array{..} =

466466 r <- peek p

467467 touchForeignPtr aStart

468468 return r

469− in x `K.cons` go (p `plusPtr` (sizeOf (undefined :: a)))

469+ in x `K.cons` go (p `plusPtr` sizeOf (undefined :: a))

470470

471471{-# INLINE_NORMAL toStreamDRev #-}

472472toStreamDRev :: forall m a. (Monad m, Storable a) => Array a -> D.Stream m a

@@ -584,7 +584,7 @@ writeNUnsafe n = Fold step initial extract

584584 return $ ArrayUnsafe start end

585585 step (ArrayUnsafe start end) x = do

586586 liftIO $ poke end x

587− return $ (ArrayUnsafe start (end `plusPtr` sizeOf (undefined :: a)))

587+ return $ ArrayUnsafe start (end `plusPtr` sizeOf (undefined :: a))

588588 extract (ArrayUnsafe start end) = return $ Array start end end -- liftIO . shrinkToFit

589589

590590-- XXX The realloc based implementation needs to make one extra copy if we use

@@ -739,7 +739,7 @@ flattenArrays (D.Stream step state) = D.Stream step' (OuterLoop state)

739739 touchForeignPtr startf

740740 return r

741741 return $ D.Yield x (InnerLoop st startf

742− (p `plusPtr` (sizeOf (undefined :: a))) end)

742+ (p `plusPtr` sizeOf (undefined :: a)) end)

743743

744744{-# INLINE_NORMAL flattenArraysRev #-}

745745flattenArraysRev :: forall m a. (MonadIO m, Storable a)

@@ -811,7 +811,7 @@ toListFB c n Array{..} = go (unsafeForeignPtrToPtr aStart)

811811 r <- peek p

812812 touchForeignPtr aStart

813813 return r

814− in c x (go (p `plusPtr` (sizeOf (undefined :: a))))

814+ in c x (go (p `plusPtr` sizeOf (undefined :: a)))

815815

816816-- | Convert an 'Array' into a list.

817817--

@@ -842,9 +842,7 @@ fromList xs = unsafePerformIO $ fromStreamD $ D.fromList xs

842842

843843instance (Storable a, Read a, Show a) => Read (Array a) where

844844 {-# INLINE readPrec #-}

845− readPrec = do

846− xs <- readPrec

847− return (fromList xs)

845+ readPrec = fromList <$> readPrec

848846 readListPrec = readListPrecDefault

849847

850848instance (a ~ Char) => IsString (Array a) where

@@ -1037,7 +1035,7 @@ unlines sep (D.Stream step state) = D.Stream step' (OuterLoop state)

10371035 touchForeignPtr startf

10381036 return r

10391037 return $ D.Yield x (InnerLoop st startf

1040− (p `plusPtr` (sizeOf (undefined :: a))) end)

1038+ (p `plusPtr` sizeOf (undefined :: a)) end)

10411039

10421040-- Splice an array into a pre-reserved mutable array. The user must ensure

10431041-- that there is enough space in the mutable array.

@@ -1048,7 +1046,7 @@ spliceWith dst@(Array _ end bound) src = liftIO $ do

10481046 if end `plusPtr` srcLen > bound

10491047 then error "Bug: spliceIntoUnsafe: Not enough space in the target array"

10501048 else

1051− withForeignPtr (aStart dst) $ \_ -> do

1049+ withForeignPtr (aStart dst) $ \_ ->

10521050 withForeignPtr (aStart src) $ \psrc -> do

10531051 let pdst = aEnd dst

10541052 memcpy (castPtr pdst) (castPtr psrc) srcLen

@@ -1109,7 +1107,7 @@ packArraysChunksOf n (D.Stream step state) =

11091107 then D.Skip (SpliceYielding arr (SpliceInitial s))

11101108 else D.Skip (SpliceBuffering s arr)

11111109 D.Skip s -> return $ D.Skip (SpliceInitial s)

1112− D.Stop -> return $ D.Stop

1110+ D.Stop -> return D.Stop

11131111

11141112 step' gst (SpliceBuffering st buf) = do

11151113 r <- step gst st

@@ -1155,7 +1153,7 @@ lpackArraysChunksOf n (Fold step1 initial1 extract1) =

11551153 r <- step1 r1 buf

11561154 extract1 r

11571155

1158− step (Tuple' Nothing r1) arr = do

1156+ step (Tuple' Nothing r1) arr =

11591157 let len = byteLength arr

11601158 in if len >= n

11611159 then do

@@ -1222,7 +1220,7 @@ groupIOVecsOf n maxIOVLen (D.Stream step state) =

12221220 then return $ D.Skip (GatherYielding iov' (GatherInitial s))

12231221 else return $ D.Skip (GatherBuffering s iov' len)

12241222 D.Skip s -> return $ D.Skip (GatherInitial s)

1225− D.Stop -> return $ D.Stop

1223+ D.Stop -> return D.Stop

12261224

12271225 step' gst (GatherBuffering st iov len) = do

12281226 r <- step (adaptState gst) st

@@ -1330,7 +1328,7 @@ splitOn byte (D.Stream step state) = D.Stream step' (Initial state)

13301328 Nothing -> D.Skip (Buffering s arr1)

13311329 Just arr2 -> D.Skip (Yielding arr1 (Splitting s arr2))

13321330 D.Skip s -> return $ D.Skip (Initial s)

1333− D.Stop -> return $ D.Stop

1331+ D.Stop -> return D.Stop

13341332

13351333 step' gst (Buffering st buf) = do

13361334 r <- step gst st

@@ -1354,4 +1352,4 @@ splitOn byte (D.Stream step state) = D.Stream step' (Initial state)

13541352 Just arr2 -> D.Skip $ Yielding arr1 (Splitting st arr2)

13551353

13561354 step' _ (Yielding arr next) = return $ D.Yield arr next

1357− step' _ Finishing = return $ D.Stop

1355+ step' _ Finishing = return D.Stop

src/Streamly/Internal/Memory/ArrayStream.hs−3

@@ -1,8 +1,5 @@

1−{-# LANGUAGE BangPatterns #-}

21{-# LANGUAGE CPP #-}

3−{-# LANGUAGE MagicHash #-}

42{-# LANGUAGE RecordWildCards #-}

5−{-# LANGUAGE UnboxedTuples #-}

63{-# LANGUAGE ScopedTypeVariables #-}

85#include "inline.hs"