d70bac4 · streamly · git.iko.soy

git.iko.soy/streamly

on master help sign in

Merge pull request #447

d70bac4pranaysashank7 years ago

.hlint.yaml+3

compare with master

unifiedsplit

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

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

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

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

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

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

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

19# Specify additional command line arguments

22# Specify additional command line arguments

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

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

1{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

3−{-# LANGUAGE MagicHash #-}

4−{-# LANGUAGE RecordWildCards #-}

5−{-# LANGUAGE UnboxedTuples #-}

7#include "inline.hs"

3#include "inline.hs"

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

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

1{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

3{-# LANGUAGE FlexibleContexts #-}

2{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE MagicHash #-}

5−{-# LANGUAGE RecordWildCards #-}

6−{-# LANGUAGE UnboxedTuples #-}

8#include "inline.hs"

4#include "inline.hs"

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

180-- @since 0.7.0

176-- @since 0.7.0

181{-# INLINABLE writeArray #-}

177{-# INLINABLE writeArray #-}

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

178writeArray :: 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)

184

180

185-- | append an array to a file.

181-- | append an array to a file.

186--

182--

187-- @since 0.7.0

183-- @since 0.7.0

188{-# INLINABLE appendArray #-}

184{-# INLINABLE appendArray #-}

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

185appendArray :: 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)

191

187

192-------------------------------------------------------------------------------

188-------------------------------------------------------------------------------

193-- Stream of Arrays IO

189-- Stream of Arrays IO

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

353 initial = do

349 initial = do

354 h <- liftIO (openFile path WriteMode)

350 h <- liftIO (openFile path WriteMode)

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

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

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

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

357 return (fld, h)

353 return (fld, h)

358 step (fld, h) x = do

354 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)

360 return (r, h)

356 return (r, h)

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

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

362 liftIO $ hClose h

358 liftIO $ hClose h

363 initial1 >>= extract1

359 initial1 >>= extract1

364

360

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

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

1{-# LANGUAGE CPP #-}

2−{-# LANGUAGE BangPatterns #-}

3{-# LANGUAGE FlexibleContexts #-}

2{-# LANGUAGE FlexibleContexts #-}

4−{-# LANGUAGE MagicHash #-}

5{-# LANGUAGE RecordWildCards #-}

3{-# LANGUAGE RecordWildCards #-}

6−{-# LANGUAGE UnboxedTuples #-}

8#include "inline.hs"

5#include "inline.hs"

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

352{-# INLINE fromChunks #-}

349{-# INLINE fromChunks #-}

353fromChunks :: (MonadIO m, Storable a)

350fromChunks :: (MonadIO m, Storable a)

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

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

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

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

356

353

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

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

358--

355--

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

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

1{-# LANGUAGE BangPatterns #-}

2{-# LANGUAGE CPP #-}

3{-# LANGUAGE MagicHash #-}

4−{-# LANGUAGE RecordWildCards #-}

5{-# LANGUAGE UnboxedTuples #-}

4{-# LANGUAGE UnboxedTuples #-}

6{-# LANGUAGE ScopedTypeVariables #-}

5{-# LANGUAGE ScopedTypeVariables #-}

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

129 )

128 )

130where

129where

131

130

131+import Control.Monad (when)

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

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

134import Foreign.ForeignPtr (withForeignPtr, touchForeignPtr)

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

173{-# INLINE fromStreamN #-}

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

175fromStreamN 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"

177 A.fromStreamDN n $ D.toStreamD m

178

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

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

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

231

232 {-# INLINE_LATE step #-}

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

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

234 let x = A.unsafeInlineIO $ touchForeignPtr fp

235 in x `seq` return D.Stop

236 step (ReadUState fp p) = do

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

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

243 let !x = A.unsafeInlineIO $ peek p

244 return $ D.Yield x

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

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

246

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

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

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

274 r <- peek (Ptr p)

275 touch contents

276 return r

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

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

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

279

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

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

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

403 then Nothing

404 else A.unsafeInlineIO $

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

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

406

407{-

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

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

500-- /Internal/

501{-# INLINE fold #-}

502fold :: 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)

504

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

506--

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

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

89import Control.Exception (assert)

90import Control.DeepSeq (NFData(..))

91−import Control.Monad (when)

91+import Control.Monad (when, void)

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

93import Data.Functor.Identity (runIdentity)

94#if __GLASGOW_HASKELL__ < 808

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

208

209-- XXX we are converting Int to CSize

210memcpy :: 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))

212

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

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

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

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

294 poke aEnd x

295 touchForeignPtr aStart

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

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

297

298{-# INLINE snoc #-}

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

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

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

301− if (aEnd == aBound)

301+ if aEnd == aBound

302 then do

303 let oldStart = unsafeForeignPtrToPtr aStart

304 size = aEnd `minusPtr` oldStart

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

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

306 newPtr <- Malloc.mallocForeignPtrAlignedBytes

307 newSize (alignment (undefined :: a))

308 withForeignPtr newPtr $ \pNew -> do

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

317 else do

318 poke aEnd x

319 touchForeignPtr aStart

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

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

321

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

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

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

449 r <- peek p

450 touchForeignPtr aStart

451 return r

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

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

453

454{-# INLINE toStreamK #-}

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

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

466 r <- peek p

467 touchForeignPtr aStart

468 return r

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

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

470

471{-# INLINE_NORMAL toStreamDRev #-}

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

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

584 return $ ArrayUnsafe start end

585 step (ArrayUnsafe start end) x = do

586 liftIO $ poke end x

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

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

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

589

590-- 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)

739 touchForeignPtr startf

740 return r

741 return $ D.Yield x (InnerLoop st startf

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

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

743

744{-# INLINE_NORMAL flattenArraysRev #-}

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

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

811 r <- peek p

812 touchForeignPtr aStart

813 return r

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

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

815

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

817--

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

842

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

844 {-# INLINE readPrec #-}

845− readPrec = do

845+ readPrec = fromList <$> readPrec

846− xs <- readPrec

847− return (fromList xs)

848 readListPrec = readListPrecDefault

846 readListPrec = readListPrecDefault

849

847

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

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

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

1037 touchForeignPtr startf

1035 touchForeignPtr startf

1038 return r

1036 return r

1039 return $ D.Yield x (InnerLoop st startf

1037 return $ D.Yield x (InnerLoop st startf

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

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

1041

1039

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

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

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

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

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

1048 if end `plusPtr` srcLen > bound

1046 if end `plusPtr` srcLen > bound

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

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

1050 else

1048 else

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

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

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

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

1053 let pdst = aEnd dst

1051 let pdst = aEnd dst

1054 memcpy (castPtr pdst) (castPtr psrc) srcLen

1052 memcpy (castPtr pdst) (castPtr psrc) srcLen

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

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

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

1110 else D.Skip (SpliceBuffering s arr)

1108 else D.Skip (SpliceBuffering s arr)

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

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

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

1110+ D.Stop -> return D.Stop

1113

1111

1114 step' gst (SpliceBuffering st buf) = do

1112 step' gst (SpliceBuffering st buf) = do

1115 r <- step gst st

1113 r <- step gst st

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

1155 r <- step1 r1 buf

1153 r <- step1 r1 buf

1156 extract1 r

1154 extract1 r

1157

1155

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

1156+ step (Tuple' Nothing r1) arr =

1159 let len = byteLength arr

1157 let len = byteLength arr

1160 in if len >= n

1158 in if len >= n

1161 then do

1159 then do

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

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

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

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

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

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

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

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

1223+ D.Stop -> return D.Stop

1226

1224

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

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

1228 r <- step (adaptState gst) st

1226 r <- step (adaptState gst) st

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

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

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

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

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

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

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

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

1331+ D.Stop -> return D.Stop

1334

1332

1335 step' gst (Buffering st buf) = do

1333 step' gst (Buffering st buf) = do

1336 r <- step gst st

1334 r <- step gst st

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

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

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

1355

1353

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

1354 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 #-}

2{-# LANGUAGE CPP #-}

1{-# LANGUAGE CPP #-}

3−{-# LANGUAGE MagicHash #-}

4{-# LANGUAGE RecordWildCards #-}

2{-# LANGUAGE RecordWildCards #-}

5−{-# LANGUAGE UnboxedTuples #-}

6{-# LANGUAGE ScopedTypeVariables #-}

3{-# LANGUAGE ScopedTypeVariables #-}

8#include "inline.hs"

5#include "inline.hs"