fix(HLint): rewrite occurrences of 'return' to 'pure'

Author: wenkokke

bench/macro/lsm-tree-bench-bloomfilter.hs

@@ -113,7 +113,7 @@ benchmarks = do
                 hashcost
                 0
 
-    return ()
+    pure ()
 
 type Alloc = Int
 
@@ -160,7 +160,7 @@ benchmark name description action n (subtractTime, subtractAlloc) expectedAlloc
             (truncate allocPerKey :: Int)
 
     putStrLn ""
-    return (timeNet, allocNet)
+    pure (timeNet, allocNet)
 
 -- | (numEntries, sizeFactor, (BloomSize numBits numHashFuncs))
 type BloomFilterSizeInfo = (Integer, Integer, BloomSize)
@@ -233,7 +233,7 @@ elemManyEnv filterSizes rng0 =
          let k :: Word256
              (!k, !rng') = uniform rng
          Bloom.insert mb (serialiseKey k)
-         return rng'
+         pure rng'
       )
       rng0
       (zip [0 .. totalNumEntries filterSizes - 1]

bench/macro/lsm-tree-bench-lookups.hs

@@ -267,7 +267,7 @@ benchmark name description action n (subtractTime, subtractAlloc) = do
     printStat "Alloc net per key: " allocPerKey "bytes"
 
     putStrLn ""
-    return (timeNet, allocNet)
+    pure (timeNet, allocNet)
 
 -- | (numEntries, sizeFactor)
 type RunSizeInfo = (Int, Int)

bench/macro/lsm-tree-bench-wp8.hs

@@ -122,7 +122,7 @@ makeKey seed =
            case v of
              P.MutablePrimArray mba -> do
                _ <- P.resizeMutableByteArray (P.MutableByteArray mba) 34
-               return v
+               pure v
 
       of (P.PrimArray ba :: P.PrimArray Word64) ->
            byteArrayToSBS (P.ByteArray ba)
@@ -262,7 +262,7 @@ timed action = do
     printf "Running time:  %.03f sec\n" t
     printf "/proc/self/io after vs. before: %s\n" (ppShow p)
     printf "RTSStats after vs. before: %s\n" (ppShow s)
-    return (x, t, s, p)
+    pure (x, t, s, p)
 
 timed_ :: IO () -> IO (Double, RTSStatsDiff Triple, ProcIODiff)
 timed_ action = do
@@ -479,7 +479,7 @@ doDryRun' gopts opts = do
         let (batch1, batch2) = toOperations lookups inserts
         _ <- evaluate $ force (batch1, batch2)
 
-        return g'
+        pure g'
 
     when (check opts) $ do
         duplicates <- readIORef duplicateRef
@@ -589,7 +589,7 @@ doRun gopts opts = do
         checkvar <- newIORef $ pureReference
                                 (initialSize gopts) (batchSize opts)
                                 (batchCount opts) (seed opts)
-        let fcheck | not (check opts) = \_ _ -> return ()
+        let fcheck | not (check opts) = \_ _ -> pure ()
                    | otherwise = \b y -> do
               (x:xs) <- readIORef checkvar
               unless (x == y) $
@@ -642,7 +642,7 @@ sequentialIteration h output !initialSize !batchSize !tbl !b !g =
     _ <- timeLatency tref $ LSM.updates tbl is
 
     -- continue to the next batch
-    return g'
+    pure g'
 
 
 sequentialIterations :: LatencyHandle
@@ -674,7 +674,7 @@ sequentialIterationLO output !initialSize !batchSize !tbl !b !g = do
     output b (V.zip ls (fmap (fmap (const ())) results))
 
     -- continue to the next batch
-    return g'
+    pure g'
 
 sequentialIterationsLO :: (Int -> LookupResults -> IO ())
                        -> Int -> Int -> Int -> Word64
@@ -780,7 +780,7 @@ pipelinedIteration h output !initialSize !batchSize
           !delta' = Map.fromList (V.toList is)
       putMVar syncTblOut (tbl_n2, delta')
 
-    return tbl_n2
+    pure tbl_n2
   where
     applyUpdates :: Map K (LSM.Update V a)
                  -> V.Vector (K, LSM.LookupResult V b)
@@ -839,7 +839,7 @@ pipelinedIterations h output !initialSize !batchSize !batchCount !seed tbl_0 = d
     -- If run with +RTS -N2 then we'll put each thread on a separate core.
     withAsyncOn 0 threadA $ \ta ->
       withAsyncOn 1 threadB $ \tb ->
-        waitBoth ta tb >> return ()
+        waitBoth ta tb >> pure ()
 
 -------------------------------------------------------------------------------
 -- Testing
@@ -1020,7 +1020,7 @@ main = do
 forFoldM_ :: Monad m => s -> [a] -> (a -> s -> m s) -> m s
 forFoldM_ !s0 xs0 f = go s0 xs0
   where
-    go !s []     = return s
+    go !s []     = pure s
     go !s (x:xs) = do
       !s' <- f x s
       go s' xs

bench/macro/rocksdb-bench-wp8.hs

@@ -156,14 +156,14 @@ timed action = do
     x  <- action
     t2 <- Clock.getTime Clock.Monotonic
     let !t = fromIntegral (Clock.toNanoSecs (Clock.diffTimeSpec t2 t1)) * 1e-9
-    return (x, t)
+    pure (x, t)
 
 timed_ :: IO () -> IO Double
 timed_ action = do
     t1 <- Clock.getTime Clock.Monotonic
     action
     t2 <- Clock.getTime Clock.Monotonic
-    return $! fromIntegral (Clock.toNanoSecs (Clock.diffTimeSpec t2 t1)) * 1e-9
+    pure $! fromIntegral (Clock.toNanoSecs (Clock.diffTimeSpec t2 t1)) * 1e-9
 
 -------------------------------------------------------------------------------
 -- setup
@@ -270,7 +270,7 @@ doDryRun' gopts opts = do
             let k = makeKey k'
             evaluate k >> evaluate (makeValue k)
 
-        return nextG
+        pure nextG
 
     when (check opts) $ do
         duplicates <- readIORef duplicateRef
@@ -376,7 +376,7 @@ doRun' gopts opts =
 
                 RocksDB.write db wopts batch
 
-            return nextG
+            pure nextG
   where
     initGen = MCG.make
         (fromIntegral $ initialSize gopts + batchSize opts * batchCount opts)
@@ -409,7 +409,7 @@ main = do
 -------------------------------------------------------------------------------
 
 forFoldM_ :: Monad m => s -> [a] -> (a -> s -> m s) -> m s
-forFoldM_ !s []     _ = return s
+forFoldM_ !s []     _ = pure s
 forFoldM_ !s (x:xs) f = do
     !s' <- f x s
     forFoldM_ s' xs f

bench/micro/Bench/Database/LSMTree/Internal/Index.hs

@@ -37,13 +37,13 @@ benchmarks = bgroup "Bench.Database.LSMTree.Internal.Index" $
         = bgroup (indexTypeName ++ " index") $
           [
               -- Search
-              env (return $ searchIndex indexType 10000) $ \ index ->
-              env (return $ searchKeys 1000)             $ \ keys  ->
+              env (pure $ searchIndex indexType 10000) $ \ index ->
+              env (pure $ searchKeys 1000)             $ \ keys  ->
               bench "Search" $
               searchBenchmarkable index keys,
 
               -- Incremental construction
-              env (return $ incrementalConstructionAppends 10000) $ \ appends ->
+              env (pure $ incrementalConstructionAppends 10000) $ \ appends ->
               bench "Incremental construction" $
               incrementalConstructionBenchmarkable indexType appends
           ]

blockio/src-sim/System/FS/BlockIO/Sim.hs

@@ -82,14 +82,14 @@ simTryLockFile hfs path lockmode =
                                      mkLockFileHandle
         ExclusiveLock | n == 0 -> do writeCount h (-1)
                                      mkLockFileHandle
-        _                      -> return Nothing
+        _                      -> pure Nothing
   where
     mkLockFileHandle = do
       -- A lock file handle keeps open the file in read mode, such that a locked
       -- file contributes to the number of open file handles. The mock FS allows
       -- multiple readers and up to one writer to open the file concurrently.
       h <- API.hOpen hfs path ReadMode
-      return (Just (LockFileHandle { hUnlock = hUnlock h }))
+      pure (Just (LockFileHandle { hUnlock = hUnlock h }))
 
     hUnlock h0 =
       API.withFile hfs path (ReadWriteMode AllowExisting) $ \h -> do
@@ -112,7 +112,7 @@ simTryLockFile hfs path lockmode =
     writeCount h n = do
       API.hSeek hfs h AbsoluteSeek 0
       _ <- API.hPutAllStrict hfs h (BS.pack (show n))
-      return ()
+      pure ()
 
     countCorrupt =
       FsError {

blockio/src/System/FS/BlockIO/API.hs

@@ -321,7 +321,7 @@ rethrowFsErrorIO hfs fp action = do
     res <- try action
     case res of
       Left err -> handleError err
-      Right a  -> return a
+      Right a  -> pure a
   where
     handleError :: HasCallStack => IOError -> IO a
     handleError ioErr =

bloomfilter/src/Data/BloomFilter/Blocked.hs

@@ -162,7 +162,7 @@ unfold bloomsize f k =
       where
         loop :: b -> ST s ()
         loop !j = case f j of
-                    Nothing      -> return ()
+                    Nothing      -> pure ()
                     Just (a, j') -> insert mb a >> loop j'
 
 -- | Create a Bloom filter, populating it from a sequence of values.
@@ -241,7 +241,7 @@ insertMany bloom key n =
               prepareProbes (i+1) (i_w+1)
 
           | n > 0     = insertProbe 0 0 i_w
-          | otherwise = return ()
+          | otherwise = pure ()
 
         -- Read from the read end of the buffer and do the inserts.
         insertProbe :: Int -> Int -> Int -> ST s ()
@@ -275,4 +275,4 @@ insertMany bloom key n =
                 i_w
 
           -- When the buffer is empty, we're done.
-          | otherwise = return ()
+          | otherwise = pure ()

bloomfilter/src/Data/BloomFilter/Blocked/BitArray.hs

@@ -97,7 +97,7 @@ new :: NumBlocks -> ST s (MBitArray s)
 new (NumBlocks numBlocks) = do
     mba@(MutableByteArray mba#) <- newAlignedPinnedByteArray numBytes 64
     setByteArray mba 0 numBytes (0 :: Word8)
-    return (MBitArray (MutablePrimArray mba#))
+    pure (MBitArray (MutablePrimArray mba#))
   where
     !numBytes = numBlocks * 64
 
@@ -126,7 +126,7 @@ unsafeSet :: MBitArray s -> BlockIx -> BitIx -> ST s ()
 unsafeSet (MBitArray arr) blockIx blockBitIx = do
 #ifdef NO_IGNORE_ASSERTS
     sz <- getSizeofMutablePrimArray arr
-    assert (wordIx >= 0 && wordIx < sz) $ return ()
+    assert (wordIx >= 0 && wordIx < sz) $ pure ()
 #endif
     w <- readPrimArray arr wordIx
     writePrimArray arr wordIx (unsafeSetBit w wordBitIx)
@@ -146,7 +146,7 @@ prefetchSet (MBitArray (MutablePrimArray mba#)) (BlockIx blockIx) = do
 
 #ifdef NO_IGNORE_ASSERTS
     sz <- getSizeofMutableByteArray (MutableByteArray mba#)
-    assert (let i = I# i# in i >= 0 && i < sz-63) $ return ()
+    assert (let i = I# i# in i >= 0 && i < sz-63) $ pure ()
 #endif
 
     -- In prefetchMutableByteArray0, the 0 refers to a "non temporal" load,

bloomfilter/src/Data/BloomFilter/Blocked/Internal.hs

@@ -131,7 +131,7 @@ insertHashes MBloom { mbNumBlocks, mbNumHashes, mbBitArray } !h =
     (!blockIx, !g0) = blockIxAndBitGen h mbNumBlocks
 
     go :: BitIxGen -> Int -> ST s ()
-    go !_ 0  = return ()
+    go !_ 0  = pure ()
     go !g !i = do
       let blockBitIx :: BitIx
           (!blockBitIx, !g') = genBitIndex g