(return -> pure)

Author: Anton-Latukha

src/Nix/Cache.hs

@@ -24,13 +24,13 @@ readCache path = do
     eres <- C.unsafeReadCompact path
     case eres of
         Left err -> error $ "Error reading cache file: " <> err
-        Right expr -> return $ C.getCompact expr
+        Right expr -> pure $ C.getCompact expr
 #else
 #ifdef MIN_VERSION_serialise
   eres <- S.deserialiseOrFail <$> BS.readFile path
   case eres of
     Left  err  -> error $ "Error reading cache file: " <> show err
-    Right expr -> return expr
+    Right expr -> pure expr
 #else
     error "readCache not implemented for this platform"
 #endif

src/Nix/Effects.hs

@@ -92,7 +92,7 @@ instance MonadIntrospect IO where
 #if MIN_VERSION_ghc_datasize(0,2,0)
 recursiveSize
 #else
-\_ -> return 0
+\_ -> pure 0
 #endif
 #else
     \_ -> pure 0
@@ -269,31 +269,31 @@ class Monad m => MonadStore m where
 
 parseStoreResult :: Monad m => String -> (Either String a, [Store.Remote.Logger]) -> m (Either ErrorCall a)
 parseStoreResult name res = case res of
-  (Left msg, logs) -> return $ Left $ ErrorCall $ "Failed to execute '" <> name <> "': " <> msg <> "\n" <> show logs
-  (Right result, _) -> return $ Right result
+  (Left msg, logs) -> pure $ Left $ ErrorCall $ "Failed to execute '" <> name <> "': " <> msg <> "\n" <> show logs
+  (Right result, _) -> pure $ Right result
 
 instance MonadStore IO where
 
   addToStore name path recursive repair = case Store.makeStorePathName name of
-    Left err -> return $ Left $ ErrorCall $ "String '" <> show name <> "' is not a valid path name: " <> err
+    Left err -> pure $ Left $ ErrorCall $ "String '" <> show name <> "' is not a valid path name: " <> err
     Right pathName -> do
       -- TODO: redesign the filter parameter
       res <- Store.Remote.runStore $ Store.Remote.addToStore @'Store.SHA256 pathName path recursive (const False) repair
       parseStoreResult "addToStore" res >>= \case
-        Left err -> return $ Left err
-        Right storePath -> return $ Right $ StorePath $ T.unpack $ T.decodeUtf8 $ Store.storePathToRawFilePath storePath
+        Left err -> pure $ Left err
+        Right storePath -> pure $ Right $ StorePath $ T.unpack $ T.decodeUtf8 $ Store.storePathToRawFilePath storePath
 
   addTextToStore' name text references repair = do
     res <- Store.Remote.runStore $ Store.Remote.addTextToStore name text references repair
     parseStoreResult "addTextToStore" res >>= \case
-      Left err -> return $ Left err
-      Right path -> return $ Right $ StorePath $ T.unpack $ T.decodeUtf8 $ Store.storePathToRawFilePath path
+      Left err -> pure $ Left err
+      Right path -> pure $ Right $ StorePath $ T.unpack $ T.decodeUtf8 $ Store.storePathToRawFilePath path
 
 addTextToStore :: (Framed e m, MonadStore m) => StorePathName -> Text -> Store.StorePathSet -> RepairFlag -> m StorePath
-addTextToStore a b c d = either throwError return =<< addTextToStore' a b c d
+addTextToStore a b c d = either throwError pure =<< addTextToStore' a b c d
 
 addPath :: (Framed e m, MonadStore m) => FilePath -> m StorePath
-addPath p = either throwError return =<< addToStore (T.pack $ takeFileName p) p True False
+addPath p = either throwError pure =<< addToStore (T.pack $ takeFileName p) p True False
 
 toFile_ :: (Framed e m, MonadStore m) => FilePath -> String -> m StorePath
 toFile_ p contents = addTextToStore (T.pack p) (T.pack contents) HS.empty False

src/Nix/Effects/Basic.hs

@@ -105,7 +105,7 @@ findEnvPathM name = do
     isDir   <- doesDirectoryExist absPath
     absFile <- if isDir
       then makeAbsolutePath @t @f $ absPath </> "default.nix"
-      else return absPath
+      else pure absPath
     exists <- doesFileExist absFile
     pure $ if exists then pure absFile else Nothing
 

src/Nix/Effects/Derivation.hs

@@ -86,12 +86,12 @@ data HashMode = Flat | Recursive
 makeStorePathName :: (Framed e m) => Text -> m Store.StorePathName
 makeStorePathName name = case Store.makeStorePathName name of
   Left err -> throwError $ ErrorCall $ "Invalid name '" <> show name <> "' for use in a store path: " <> err
-  Right spname -> return spname
+  Right spname -> pure spname
 
 parsePath :: (Framed e m) => Text -> m Store.StorePath
 parsePath p = case Store.parsePath "/nix/store" (Text.encodeUtf8 p) of
   Left err -> throwError $ ErrorCall $ "Cannot parse store path " <> show p <> ":\n" <> show err
-  Right path -> return path
+  Right path -> pure path
 
 writeDerivation :: (Framed e m, MonadStore m) => Derivation -> m Store.StorePath
 writeDerivation drv@Derivation{inputs, name} = do
@@ -108,7 +108,7 @@ hashDerivationModulo (Derivation {
     outputs,
     hashMode
   }) = case Map.toList outputs of
-    [("out", path)] -> return $ Store.hash @'Store.SHA256 $ Text.encodeUtf8
+    [("out", path)] -> pure $ Store.hash @'Store.SHA256 $ Text.encodeUtf8
       $  "fixed:out"
       <> (if hashMode == Recursive then ":r" else "")
       <> ":" <> (Store.algoName @hashType)
@@ -119,13 +119,13 @@ hashDerivationModulo drv@Derivation{inputs = (inputSrcs, inputDrvs)} = do
   cache <- gets snd
   inputsModulo <- Map.fromList <$> forM (Map.toList inputDrvs) (\(path, outs) ->
     case MS.lookup path cache of
-      Just hash -> return (hash, outs)
+      Just hash -> pure (hash, outs)
       Nothing -> do
         drv' <- readDerivation $ Text.unpack path
         hash <- Store.encodeInBase Store.Base16 <$> hashDerivationModulo drv'
-        return (hash, outs)
+        pure (hash, outs)
     )
-  return $ Store.hash @'Store.SHA256 $ Text.encodeUtf8 $ unparseDrv (drv {inputs = (inputSrcs, inputsModulo)})
+  pure $ Store.hash @'Store.SHA256 $ Text.encodeUtf8 $ unparseDrv (drv {inputs = (inputSrcs, inputsModulo)})
 
 unparseDrv :: Derivation -> Text
 unparseDrv Derivation{..} = Text.append "Derive" $ parens
@@ -169,7 +169,7 @@ readDerivation path = do
   content <- Text.decodeUtf8 <$> readFile path
   case parse derivationParser path content of
     Left err -> throwError $ ErrorCall $ "Failed to parse " <> show path <> ":\n" <> show err
-    Right drv -> return drv
+    Right drv -> pure drv
 
 derivationParser :: Parsec () Text Derivation
 derivationParser = do
@@ -197,7 +197,7 @@ derivationParser = do
   let name = "" -- FIXME (extract from file path ?)
   let useJson = ["__json"] == Map.keys env
 
-  return $ Derivation {inputs = (inputSrcs, inputDrvs), ..}
+  pure $ Derivation {inputs = (inputSrcs, inputDrvs), ..}
  where
   s :: Parsec () Text Text
   s = fmap Text.pack $ string "\"" *> manyTill (escaped <|> regular) (string "\"")
@@ -238,7 +238,7 @@ defaultDerivationStrict = fromValue @(AttrSet (NValue t f m)) >=> \s -> do
       Just (Store.SomeDigest digest) -> do
         let out = pathToText $ Store.makeFixedOutputPath "/nix/store" (hashMode drv == Recursive) digest drvName
         let env' = if useJson drv then env drv else Map.insert "out" out (env drv)
-        return $ drv { inputs, env = env', outputs = Map.singleton "out" out }
+        pure $ drv { inputs, env = env', outputs = Map.singleton "out" out }
 
       Nothing -> do
         hash <- hashDerivationModulo $ drv
@@ -248,7 +248,7 @@ defaultDerivationStrict = fromValue @(AttrSet (NValue t f m)) >=> \s -> do
                   else foldl' (\m k -> Map.insert k "" m) (env drv) (Map.keys $ outputs drv)
           }
         outputs' <- sequence $ Map.mapWithKey (\o _ -> makeOutputPath o hash drvName) (outputs drv)
-        return $ drv
+        pure $ drv
           { inputs
           , outputs = outputs'
           , env = if useJson drv then env drv else Map.union outputs' (env drv)
@@ -265,15 +265,15 @@ defaultDerivationStrict = fromValue @(AttrSet (NValue t f m)) >=> \s -> do
         attrSet = M.map nvStr $ M.fromList $ ("drvPath", drvPathWithContext): Map.toList outputsWithContext
     -- TODO: Add location information for all the entries.
     --              here --v
-    return $ nvSet attrSet M.empty
+    pure $ nvSet attrSet M.empty
 
   where
 
     pathToText = Text.decodeUtf8 . Store.storePathToRawFilePath
 
     makeOutputPath o h n = do
       name <- makeStorePathName (Store.unStorePathName n <> if o == "out" then "" else "-" <> o)
-      return $ pathToText $ Store.makeStorePath "/nix/store" ("output:" <> Text.encodeUtf8 o) h name
+      pure $ pathToText $ Store.makeStorePath "/nix/store" ("output:" <> Text.encodeUtf8 o) h name
 
     toStorePaths ctx = foldl (flip addToInputs) (Set.empty, Map.empty) ctx
     addToInputs (StringContext path kind) = case kind of
@@ -294,43 +294,43 @@ buildDerivationWithContext drvAttrs = do
     drvName     <- getAttr   "name"                      $ extractNixString >=> assertDrvStoreName
     withFrame' Info (ErrorCall $ "While evaluating derivation " <> show drvName) $ do
 
-      useJson     <- getAttrOr "__structuredAttrs" False   $ return
-      ignoreNulls <- getAttrOr "__ignoreNulls"     False   $ return
+      useJson     <- getAttrOr "__structuredAttrs" False   $ pure
+      ignoreNulls <- getAttrOr "__ignoreNulls"     False   $ pure
 
       args        <- getAttrOr "args"              []      $ mapM (fromValue' >=> extractNixString)
       builder     <- getAttr   "builder"                   $ extractNixString
       platform    <- getAttr   "system"                    $ extractNoCtx >=> assertNonNull
-      mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (return . pure)
+      mHash       <- getAttrOr "outputHash"        Nothing $ extractNoCtx >=> (pure . pure)
       hashMode    <- getAttrOr "outputHashMode"    Flat    $ extractNoCtx >=> parseHashMode
       outputs     <- getAttrOr "outputs"           ["out"] $ mapM (fromValue' >=> extractNoCtx)
 
       mFixedOutput <- case mHash of
-        Nothing -> return Nothing
+        Nothing -> pure Nothing
         Just hash -> do
           when (outputs /= ["out"]) $ lift $ throwError $ ErrorCall $ "Multiple outputs are not supported for fixed-output derivations"
           hashType <- getAttr "outputHashAlgo" $ extractNoCtx
-          digest <- lift $ either (throwError . ErrorCall) return $ Store.mkNamedDigest hashType hash
-          return $ pure digest
+          digest <- lift $ either (throwError . ErrorCall) pure $ Store.mkNamedDigest hashType hash
+          pure $ pure digest
 
       -- filter out null values if needed.
       attrs <- if not ignoreNulls
-        then return drvAttrs
+        then pure drvAttrs
         else M.mapMaybe id <$> forM drvAttrs (demand' ?? (\case
-            NVConstant NNull -> return Nothing
-            value -> return $ pure value
+            NVConstant NNull -> pure Nothing
+            value -> pure $ pure value
           ))
 
       env <- if useJson
         then do
           jsonString :: NixString <- lift $ nvalueToJSONNixString $ flip nvSet M.empty $
             deleteKeys [ "args", "__ignoreNulls", "__structuredAttrs" ] attrs
           rawString :: Text <- extractNixString jsonString
-          return $ Map.singleton "__json" rawString
+          pure $ Map.singleton "__json" rawString
         else
           mapM (lift . coerceToString callFunc CopyToStore CoerceAny >=> extractNixString) $
             Map.fromList $ M.toList $ deleteKeys [ "args", "__ignoreNulls" ] attrs
 
-      return $ defaultDerivation { platform, builder, args, env,  hashMode, useJson
+      pure $ defaultDerivation { platform, builder, args, env,  hashMode, useJson
         , name = drvName
         , outputs = Map.fromList $ fmap (\o -> (o, "")) outputs
         , mFixed = mFixedOutput
@@ -339,13 +339,13 @@ buildDerivationWithContext drvAttrs = do
     -- common functions, lifted to WithStringContextT
 
     demand' :: NValue t f m -> (NValue t f m -> WithStringContextT m a) -> WithStringContextT m a
-    demand' v f = join $ lift $ demand v (return . f)
+    demand' v f = join $ lift $ demand v (pure . f)
 
     fromValue' :: (FromValue a m (NValue' t f m (NValue t f m)), MonadNix e t f m) => NValue t f m -> WithStringContextT m a
     fromValue' = lift . fromValue
 
     withFrame' :: (Framed e m, Exception s) => NixLevel -> s -> WithStringContextT m a -> WithStringContextT m a
-    withFrame' level f = join . lift . withFrame level f . return
+    withFrame' level f = join . lift . withFrame level f . pure
 
     -- shortcuts to get the (forced) value of an AttrSet field
 
@@ -356,7 +356,7 @@ buildDerivationWithContext drvAttrs = do
       Just v  -> withFrame' Info (ErrorCall $ "While evaluating attribute '" <> show n <> "'") $
                    fromValue' v >>= f
 
-    getAttrOr n d f = getAttrOr' n (return d) f
+    getAttrOr n d f = getAttrOr' n (pure d) f
 
     getAttr n = getAttrOr' n (throwError $ ErrorCall $ "Required attribute '" <> show n <> "' not found.")
 
@@ -370,22 +370,22 @@ buildDerivationWithContext drvAttrs = do
       when (Text.length name > 211)        $ failWith "must be no longer than 211 characters"
       when (Text.any invalid name)         $ failWith "contains some invalid character"
       when (".drv" `Text.isSuffixOf` name) $ failWith "is not allowed to end in '.drv'"
-      return name
+      pure name
 
     extractNoCtx :: MonadNix e t f m => NixString -> WithStringContextT m Text
     extractNoCtx ns = case getStringNoContext ns of
       Nothing -> lift $ throwError $ ErrorCall $ "The string " <> show ns <> " is not allowed to have a context."
-      Just v -> return v
+      Just v -> pure v
 
     assertNonNull :: MonadNix e t f m => Text -> WithStringContextT m Text
     assertNonNull t = do
       when (Text.null t) $ lift $ throwError $ ErrorCall "Value must not be empty"
-      return t
+      pure t
 
     parseHashMode :: MonadNix e t f m => Text -> WithStringContextT m HashMode
     parseHashMode = \case
-      "flat" ->      return Flat
-      "recursive" -> return Recursive
+      "flat" ->      pure Flat
+      "recursive" -> pure Recursive
       other -> lift $ throwError $ ErrorCall $ "Hash mode " <> show other <> " is not valid. It must be either 'flat' or 'recursive'"
 
     -- Other helpers

src/Nix/Fresh.hs

@@ -90,9 +90,9 @@ instance MonadAtomicRef (ST s) where
     v <- readRef r
     let (a, b) = f v
     writeRef r a
-    return b
+    pure b
   atomicModifyRef' r f = do
     v <- readRef r
     let (a, b) = f v
     writeRef r $! a
-    return b
+    pure b

src/Nix/Fresh/Basic.hs

@@ -43,10 +43,10 @@ instance (MonadEffects t f m, MonadDataContext f m)
   importPath path = do
     i <- FreshIdT ask
     p <- lift $ importPath @t @f @m path
-    return $ liftNValue (runFreshIdT i) p
+    pure $ liftNValue (runFreshIdT i) p
   pathToDefaultNix = lift . pathToDefaultNix @t @f @m
   derivationStrict v = do
     i <- FreshIdT ask
     p <- lift $ derivationStrict @t @f @m $ unliftNValue (runFreshIdT i) v
-    return $ liftNValue (runFreshIdT i) p
+    pure $ liftNValue (runFreshIdT i) p
   traceEffect = lift . traceEffect @t @f @m

src/Nix/Lint.hs

@@ -202,12 +202,12 @@ merge context = go
     mergeFunctions pl nl fl pr fr xs ys = do
         m <- sequenceA $ M.intersectionWith
             (\i j -> i >>= \i' -> j >>= \j' -> case (i', j') of
-                    (Nothing, Nothing) -> return $ pure Nothing
+                    (Nothing, Nothing) -> pure $ pure Nothing
                     (_, Nothing) -> pure Nothing
                     (Nothing, _) -> pure Nothing
                     (Just i'', Just j'') ->
                         pure . pure <$> unify context i'' j'')
-            (return <$> pl) (return <$> pr)
+            (pure <$> pl) (pure <$> pr)
         let Just m' = sequenceA $ M.filter isJust m
         if M.null m'
             then go xs ys

src/Nix/Parser.hs

@@ -608,7 +608,7 @@ nixOperators selector =
     --             Postfix $ do
     --                    sel <- seldot *> selector
     --                    mor <- optional (reserved "or" *> term)
-    --                    return $ \x -> nSelectLoc x sel mor) ]
+    --                    pure $ \x -> nSelectLoc x sel mor) ]
 
     {-  2 -}
     [ ( NBinaryDef " " NApp NAssocLeft

src/Nix/Reduce.hs

@@ -113,7 +113,7 @@ staticImport pann path = do
         local (const (pure path, emptyScopes @m @NExprLoc)) $ do
           x'' <- foldFix reduce x'
           modify (\(a, b) -> (M.insert path x'' a, b))
-          return x''
+          pure x''
 
 -- gatherNames :: NExprLoc -> HashSet VarName
 -- gatherNames = foldFix $ \case
@@ -148,10 +148,10 @@ reduce (NSym_ ann var) = lookupVar var <&> \case
 -- | Reduce binary and integer negation.
 reduce (NUnary_ uann op arg) = arg >>= \x -> case (op, x) of
   (NNeg, Fix (NConstant_ cann (NInt n))) ->
-    return $ Fix $ NConstant_ cann (NInt (negate n))
+    pure $ Fix $ NConstant_ cann (NInt (negate n))
   (NNot, Fix (NConstant_ cann (NBool b))) ->
-    return $ Fix $ NConstant_ cann (NBool (not b))
-  _ -> return $ Fix $ NUnary_ uann op x
+    pure $ Fix $ NConstant_ cann (NBool (not b))
+  _ -> pure $ Fix $ NUnary_ uann op x
 
 -- | Reduce function applications.
 --
@@ -163,7 +163,7 @@ reduce (NBinary_ bann NApp fun arg) = fun >>= \case
   f@(Fix (NSym_ _ "import")) -> arg >>= \case
       -- Fix (NEnvPath_     pann origPath) -> staticImport pann origPath
     Fix (NLiteralPath_ pann origPath) -> staticImport pann origPath
-    v -> return $ Fix $ NBinary_ bann NApp f v
+    v -> pure $ Fix $ NBinary_ bann NApp f v
 
   Fix (NAbs_ _ (Param name) body) -> do
     x <- arg
@@ -177,7 +177,7 @@ reduce (NBinary_ bann op larg rarg) = do
   rval <- rarg
   case (op, lval, rval) of
     (NPlus, Fix (NConstant_ ann (NInt x)), Fix (NConstant_ _ (NInt y))) ->
-      return $ Fix (NConstant_ ann (NInt (x + y)))
+      pure $ Fix (NConstant_ ann (NInt (x + y)))
     _ -> pure $ Fix $ NBinary_ bann op lval rval
 
 -- | Reduce a select on a Set by substituting the set to the selected value.
@@ -411,7 +411,7 @@ reducingEvalExpr eval mpath expr = do
   eres <- catch (Right <$> foldFix (addEvalFlags eval) expr') (pure . Left)
   opts :: Options <- asks (view hasLens)
   expr''          <- pruneTree opts expr'
-  return (fromMaybe nNull expr'', eres)
+  pure (fromMaybe nNull expr'', eres)
   where addEvalFlags k (FlaggedF (b, x)) = liftIO (writeIORef b True) *> k x
 
 instance Monad m => Scoped NExprLoc (Reducer m) where

src/Nix/Render.hs

@@ -92,14 +92,14 @@ renderLocation (SrcSpan (SourcePos file begLine begCol) (SourcePos file' endLine
     if exist
       then do
         txt <- sourceContext file begLine begCol endLine endCol msg
-        return
+        pure
           $ vsep
               [ "In file "
               <> errorContext file begLine begCol endLine endCol
               <> ":"
               , txt
               ]
-      else return msg
+      else pure msg
 renderLocation (SrcSpan beg end) msg =
   fail
     $  "Don't know how to render range from "