Move from return to pure

Author: ndmitchell

.ghci

@@ -3,11 +3,11 @@
 :set -isrc -itest
 :load Extra Generate Test
 :module Extra
-:def docs_ const $ return $ unlines [":!cabal haddock"]
-:def docs const $ return $ unlines [":docs_",":!start dist\\doc\\html\\extra\\Extra.html"]
-:def generate const $ return $ unlines ["Generate.main"]
-:def test const $ return $ unlines ["Test.main"]
-:def travis const $ return $ unlines [":!runhaskell -isrc travis.hs"]
+:def docs_ const $ pure $ unlines [":!cabal haddock"]
+:def docs const $ pure $ unlines [":docs_",":!start dist\\doc\\html\\extra\\Extra.html"]
+:def generate const $ pure $ unlines ["Generate.main"]
+:def test const $ pure $ unlines ["Test.main"]
+:def travis const $ pure $ unlines [":!runhaskell -isrc travis.hs"]
 
 -- if there are errors in generate or reload I want them at the bottom of the screen so I can see them
-:def go const $ return $ unlines [":reload",":generate",":reload",":test",":generate",":reload"]
+:def go const $ pure $ unlines [":reload",":generate",":reload",":test",":generate",":reload"]

Generate.hs

@@ -25,7 +25,7 @@ main = do
                     words $ replace "," " " $ drop1 $ dropWhile (/= '(') $
                     unlines $ filter (\x -> not $ any (`isPrefixOf` trim x) ["--","#"]) $ lines src
         let tests = mapMaybe (stripPrefix "-- > ") $ lines src
-        return (mod, funcs, tests)
+        pure (mod, funcs, tests)
     writeFileBinaryChanged "src/Extra.hs" $ unlines $
         ["-- GENERATED CODE - DO NOT MODIFY"
         ,"-- See Generate.hs for details of how to generate"
@@ -62,7 +62,7 @@ rejoin [] = []
 writeFileBinaryChanged :: FilePath -> String -> IO ()
 writeFileBinaryChanged file x = do
     evaluate $ length x -- ensure we don't write out files with _|_ in them
-    old <- ifM (doesFileExist file) (Just <$> readFileBinary' file) (return Nothing)
+    old <- ifM (doesFileExist file) (Just <$> readFileBinary' file) (pure Nothing)
     when (Just x /= old) $
         writeFileBinary file x
 

src/Control/Concurrent/Extra.hs

@@ -46,23 +46,23 @@ withNumCapabilities _ act = act
 --   If the function raises an exception, the same exception will be reraised each time.
 --
 -- > let x ||| y = do t1 <- onceFork x; t2 <- onceFork y; t1; t2
--- > \(x :: IO Int) -> void (once x) == return ()
+-- > \(x :: IO Int) -> void (once x) == pure ()
 -- > \(x :: IO Int) -> join (once x) == x
 -- > \(x :: IO Int) -> (do y <- once x; y; y) == x
 -- > \(x :: IO Int) -> (do y <- once x; y ||| y) == x
 once :: IO a -> IO (IO a)
 once act = do
     var <- newVar OncePending
-    let run = either throwIO return
-    return $ mask $ \unmask -> join $ modifyVar var $ \v -> case v of
-        OnceDone x -> return (v, unmask $ run x)
-        OnceRunning x -> return (v, unmask $ run =<< waitBarrier x)
+    let run = either throwIO pure
+    pure $ mask $ \unmask -> join $ modifyVar var $ \v -> case v of
+        OnceDone x -> pure (v, unmask $ run x)
+        OnceRunning x -> pure (v, unmask $ run =<< waitBarrier x)
         OncePending -> do
             b <- newBarrier
-            return $ (OnceRunning b,) $ do
+            pure $ (OnceRunning b,) $ do
                 res <- try_ $ unmask act
                 signalBarrier b res
-                modifyVar_ var $ \_ -> return $ OnceDone res
+                modifyVar_ var $ \_ -> pure $ OnceDone res
                 run res
 
 data Once a = OncePending | OnceRunning (Barrier a) | OnceDone a
@@ -76,7 +76,7 @@ onceFork :: IO a -> IO (IO a)
 onceFork act = do
     bar <- newBarrier
     forkFinally act $ signalBarrier bar
-    return $ eitherM throwIO return $ waitBarrier bar
+    pure $ eitherM throwIO pure $ waitBarrier bar
 
 
 ---------------------------------------------------------------------
@@ -115,7 +115,7 @@ withLockTry :: Lock -> IO a -> IO (Maybe a)
 withLockTry (Lock m) act = bracket
     (tryTakeMVar m)
     (\v -> when (isJust v) $ putMVar m ())
-    (\v -> if isJust v then fmap Just act else return Nothing)
+    (\v -> if isJust v then fmap Just act else pure Nothing)
 
 
 ---------------------------------------------------------------------
@@ -150,7 +150,7 @@ readVar (Var x) = readMVar x
 
 -- | Write a value to become the new value of 'Var'.
 writeVar :: Var a -> a -> IO ()
-writeVar v x = modifyVar_ v $ const $ return x
+writeVar v x = modifyVar_ v $ const $ pure x
 
 -- | Modify a 'Var' producing a new value and a return result.
 modifyVar :: Var a -> (a -> IO (a, b)) -> IO b
@@ -195,7 +195,7 @@ newBarrier = fmap Barrier $ newVar . Left =<< newEmptyMVar
 signalBarrier :: Partial => Barrier a -> a -> IO ()
 signalBarrier (Barrier var) v = mask_ $ -- use mask so never in an inconsistent state
     join $ modifyVar var $ \x -> case x of
-        Left bar -> return (Right v, putMVar bar ())
+        Left bar -> pure (Right v, putMVar bar ())
         Right res -> error "Control.Concurrent.Extra.signalBarrier, attempt to signal a barrier that has already been signaled"
 
 
@@ -204,12 +204,12 @@ waitBarrier :: Barrier a -> IO a
 waitBarrier (Barrier var) = do
     x <- readVar var
     case x of
-        Right res -> return res
+        Right res -> pure res
         Left bar -> do
             readMVar bar
             x <- readVar var
             case x of
-                Right res -> return res
+                Right res -> pure res
                 Left bar -> error "Control.Concurrent.Extra, internal invariant violated in Barrier"
 
 

src/Control/Exception/Extra.hs

@@ -35,16 +35,16 @@ import Prelude
 
 -- | Fully evaluate an input String. If the String contains embedded exceptions it will produce @\<Exception\>@.
 --
--- > stringException "test"                           == return "test"
--- > stringException ("test" ++ undefined)            == return "test<Exception>"
--- > stringException ("test" ++ undefined ++ "hello") == return "test<Exception>"
--- > stringException ['t','e','s','t',undefined]      == return "test<Exception>"
+-- > stringException "test"                           == pure "test"
+-- > stringException ("test" ++ undefined)            == pure "test<Exception>"
+-- > stringException ("test" ++ undefined ++ "hello") == pure "test<Exception>"
+-- > stringException ['t','e','s','t',undefined]      == pure "test<Exception>"
 stringException :: String -> IO String
 stringException x = do
     r <- try_ $ evaluate $ list [] (\x xs -> x `seq` x:xs) x
     case r of
-        Left e -> return "<Exception>"
-        Right [] -> return []
+        Left e -> pure "<Exception>"
+        Right [] -> pure []
         Right (x:xs) -> (x:) <$> stringException xs
 
 
@@ -66,15 +66,15 @@ errorWithoutStackTrace = error
 -- | Ignore any exceptions thrown by the action.
 --
 -- > ignore (print 1)    == print 1
--- > ignore (fail "die") == return ()
+-- > ignore (fail "die") == pure ()
 ignore :: IO () -> IO ()
 ignore = void . try_
 
 
 -- | An 'IO' action that when evaluated calls 'error', in the 'IO' monad.
 --   Note that while 'fail' in 'IO' raises an 'IOException', this function raises an 'ErrorCall' exception with a call stack.
 --
--- > catch (errorIO "Hello") (\(ErrorCall x) -> return x) == return "Hello"
+-- > catch (errorIO "Hello") (\(ErrorCall x) -> pure x) == pure "Hello"
 -- > seq (errorIO "foo") (print 1) == print 1
 errorIO :: Partial => String -> IO a
 errorIO x = withFrozenCallStack $ evaluate $ error x
@@ -103,7 +103,7 @@ retryBool p i x = do
     res <- tryBool p x
     case res of
         Left _ -> retryBool p (i-1) x
-        Right v -> return v
+        Right v -> pure v
 
 
 -- | A version of 'catch' without the 'Exception' context, restricted to 'SomeException',
@@ -135,7 +135,7 @@ tryJust_ = tryJust
 --   As an example:
 --
 -- @
--- readFileExists x == catchBool isDoesNotExistError (readFile \"myfile\") (const $ return \"\")
+-- readFileExists x == catchBool isDoesNotExistError (readFile \"myfile\") (const $ pure \"\")
 -- @
 catchBool :: Exception e => (e -> Bool) -> IO a -> (e -> IO a) -> IO a
 catchBool f a b = catchJust (bool f) a b

src/Control/Monad/Extra.hs

@@ -30,22 +30,22 @@ import Prelude
 
 -- | Perform some operation on 'Just', given the field inside the 'Just'.
 --
--- > whenJust Nothing  print == return ()
+-- > whenJust Nothing  print == pure ()
 -- > whenJust (Just 1) print == print 1
 whenJust :: Applicative m => Maybe a -> (a -> m ()) -> m ()
 whenJust mg f = maybe (pure ()) f mg
 
 -- | Like 'whenJust', but where the test can be monadic.
 whenJustM :: Monad m => m (Maybe a) -> (a -> m ()) -> m ()
 -- Can't reuse whenMaybe on GHC 7.8 or lower because Monad does not imply Applicative
-whenJustM mg f = maybeM (return ()) f mg
+whenJustM mg f = maybeM (pure ()) f mg
 
 
 -- | Like 'when', but return either 'Nothing' if the predicate was 'False',
 --   of 'Just' with the result of the computation.
 --
 -- > whenMaybe True  (print 1) == fmap Just (print 1)
--- > whenMaybe False (print 1) == return Nothing
+-- > whenMaybe False (print 1) == pure Nothing
 whenMaybe :: Applicative m => Bool -> m a -> m (Maybe a)
 whenMaybe b x = if b then Just <$> x else pure Nothing
 
@@ -54,7 +54,7 @@ whenMaybeM :: Monad m => m Bool -> m a -> m (Maybe a)
 -- Can't reuse whenMaybe on GHC 7.8 or lower because Monad does not imply Applicative
 whenMaybeM mb x = do
     b <- mb
-    if b then liftM Just x else return Nothing
+    if b then liftM Just x else pure Nothing
 
 
 -- | The identity function which requires the inner argument to be @()@. Useful for functions
@@ -89,7 +89,7 @@ fold1M f xs = error "fold1M: empty list"
 
 -- | Like 'fold1M' but discards the result.
 fold1M_ :: (Partial, Monad m) => (a -> a -> m a) -> [a] -> m ()
-fold1M_ f xs = fold1M f xs >> return ()
+fold1M_ f xs = fold1M f xs >> pure ()
 
 
 -- Data.List for Monad
@@ -99,18 +99,18 @@ fold1M_ f xs = fold1M f xs >> return ()
 -- > partitionM (Just . even) [1,2,3] == Just ([2], [1,3])
 -- > partitionM (const Nothing) [1,2,3] == Nothing
 partitionM :: Monad m => (a -> m Bool) -> [a] -> m ([a], [a])
-partitionM f [] = return ([], [])
+partitionM f [] = pure ([], [])
 partitionM f (x:xs) = do
     res <- f x
     (as,bs) <- partitionM f xs
-    return ([x | res]++as, [x | not res]++bs)
+    pure ([x | res]++as, [x | not res]++bs)
 
 
 -- | A version of 'concatMap' that works with a monadic predicate.
 concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
 {-# INLINE concatMapM #-}
-concatMapM op = foldr f (return [])
-    where f x xs = do x <- op x; if null x then xs else do xs <- xs; return $ x++xs
+concatMapM op = foldr f (pure [])
+    where f x xs = do x <- op x; if null x then xs else do xs <- xs; pure $ x++xs
 
 -- | Like 'concatMapM', but has its arguments flipped, so can be used
 --   instead of the common @fmap concat $ forM@ pattern.
@@ -124,8 +124,8 @@ mconcatMapM f = liftM mconcat . mapM f
 -- | A version of 'mapMaybe' that works with a monadic predicate.
 mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]
 {-# INLINE mapMaybeM #-}
-mapMaybeM op = foldr f (return [])
-    where f x xs = do x <- op x; case x of Nothing -> xs; Just x -> do xs <- xs; return $ x:xs
+mapMaybeM op = foldr f (pure [])
+    where f x xs = do x <- op x; case x of Nothing -> xs; Just x -> do xs <- xs; pure $ x:xs
 
 -- Looping
 
@@ -145,7 +145,7 @@ loopM act x = do
     res <- act x
     case res of
         Left x -> loopM act x
-        Right v -> return v
+        Right v -> pure v
 
 -- | Keep running an operation until it becomes 'False'. As an example:
 --
@@ -164,11 +164,11 @@ whileM act = do
 
 -- | Like 'when', but where the test can be monadic.
 whenM :: Monad m => m Bool -> m () -> m ()
-whenM b t = ifM b t (return ())
+whenM b t = ifM b t (pure ())
 
 -- | Like 'unless', but where the test can be monadic.
 unlessM :: Monad m => m Bool -> m () -> m ()
-unlessM b f = ifM b (return ()) f
+unlessM b f = ifM b (pure ()) f
 
 -- | Like @if@, but where the test can be monadic.
 ifM :: Monad m => m Bool -> m a -> m a -> m a
@@ -186,7 +186,7 @@ notM = fmap not
 -- > Just False ||^ Just True  == Just True
 -- > Just False ||^ Just False == Just False
 (||^) :: Monad m => m Bool -> m Bool -> m Bool
-(||^) a b = ifM a (return True) b
+(||^) a b = ifM a (pure True) b
 
 -- | The lazy '&&' operator lifted to a monad. If the first
 --   argument evaluates to 'False' the second argument will not
@@ -196,23 +196,23 @@ notM = fmap not
 -- > Just True  &&^ Just True  == Just True
 -- > Just True  &&^ Just False == Just False
 (&&^) :: Monad m => m Bool -> m Bool -> m Bool
-(&&^) a b = ifM a b (return False)
+(&&^) a b = ifM a b (pure False)
 
 -- | A version of 'any' lifted to a monad. Retains the short-circuiting behaviour.
 --
 -- > anyM Just [False,True ,undefined] == Just True
 -- > anyM Just [False,False,undefined] == undefined
 -- > \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)
 anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool
-anyM p = foldr ((||^) . p) (return False)
+anyM p = foldr ((||^) . p) (pure False)
 
 -- | A version of 'all' lifted to a monad. Retains the short-circuiting behaviour.
 --
 -- > allM Just [True,False,undefined] == Just False
 -- > allM Just [True,True ,undefined] == undefined
 -- > \(f :: Int -> Maybe Bool) xs -> anyM f xs == orM (map f xs)
 allM :: Monad m => (a -> m Bool) -> [a] -> m Bool
-allM p = foldr ((&&^) . p) (return True)
+allM p = foldr ((&&^) . p) (pure True)
 
 -- | A version of 'or' lifted to a monad. Retains the short-circuiting behaviour.
 --
@@ -238,9 +238,9 @@ andM = allM id
 -- > findM (Just . isUpper) "test"             == Just Nothing
 -- > findM (Just . const True) ["x",undefined] == Just (Just "x")
 findM :: Monad m => (a -> m Bool) -> [a] -> m (Maybe a)
-findM p = foldr (\x -> ifM (p x) (return $ Just x)) (return Nothing)
+findM p = foldr (\x -> ifM (p x) (pure $ Just x)) (pure Nothing)
 
 -- | Like 'findM', but also allows you to compute some additional information in the predicate.
 firstJustM :: Monad m => (a -> m (Maybe b)) -> [a] -> m (Maybe b)
-firstJustM p [] = return Nothing
-firstJustM p (x:xs) = maybeM (firstJustM p xs) (return . Just) (p x)
+firstJustM p [] = pure Nothing
+firstJustM p (x:xs) = maybeM (firstJustM p xs) (pure . Just) (p x)

src/System/Directory/Extra.hs

@@ -52,12 +52,12 @@ withCurrentDirectory dir act =
 --
 -- > withTempDir $ \dir -> do writeFile (dir </> "test.txt") ""; (== [dir </> "test.txt"]) <$> listContents dir
 -- > let touch = mapM_ $ \x -> createDirectoryIfMissing True (takeDirectory x) >> writeFile x ""
--- > let listTest op as bs = withTempDir $ \dir -> do touch $ map (dir </>) as; res <- op dir; return $ map (drop (length dir + 1)) res == bs
+-- > let listTest op as bs = withTempDir $ \dir -> do touch $ map (dir </>) as; res <- op dir; pure $ map (drop (length dir + 1)) res == bs
 -- > listTest listContents ["bar.txt","foo/baz.txt","zoo"] ["bar.txt","foo","zoo"]
 listContents :: FilePath -> IO [FilePath]
 listContents dir = do
     xs <- getDirectoryContents dir
-    return $ sort [dir </> x | x <- xs, not $ all (== '.') x]
+    pure $ sort [dir </> x | x <- xs, not $ all (== '.') x]
 
 
 -- | Like 'listContents', but only returns the directories in a directory, not the files.
@@ -81,21 +81,21 @@ listFiles dir = filterM doesFileExist =<< listContents dir
 --
 -- > listTest listFilesRecursive ["bar.txt","zoo","foo" </> "baz.txt"] ["bar.txt","zoo","foo" </> "baz.txt"]
 listFilesRecursive :: FilePath -> IO [FilePath]
-listFilesRecursive = listFilesInside (const $ return True)
+listFilesRecursive = listFilesInside (const $ pure True)
 
 
 -- | Like 'listFilesRecursive', but with a predicate to decide where to recurse into.
 --   Typically directories starting with @.@ would be ignored. The initial argument directory
 --   will have the test applied to it.
 --
--- > listTest (listFilesInside $ return . not . isPrefixOf "." . takeFileName)
+-- > listTest (listFilesInside $ pure . not . isPrefixOf "." . takeFileName)
 -- >     ["bar.txt","foo" </> "baz.txt",".foo" </> "baz2.txt", "zoo"] ["bar.txt","zoo","foo" </> "baz.txt"]
--- > listTest (listFilesInside $ const $ return False) ["bar.txt"] []
+-- > listTest (listFilesInside $ const $ pure False) ["bar.txt"] []
 listFilesInside :: (FilePath -> IO Bool) -> FilePath -> IO [FilePath]
-listFilesInside test dir = ifM (notM $ test $ dropTrailingPathSeparator dir) (return []) $ do
+listFilesInside test dir = ifM (notM $ test $ dropTrailingPathSeparator dir) (pure []) $ do
     (dirs,files) <- partitionM doesDirectoryExist =<< listContents dir
     rest <- concatMapM (listFilesInside test) dirs
-    return $ files ++ rest
+    pure $ files ++ rest
 
 
 -- | Create a directory with permissions so that only the current user can view it.