treewide: use stub

Author: Anton-Latukha

.hlint.yaml

@@ -20,12 +20,12 @@
     name: Use Foldable.forM_
 - hint:
     lhs: "pure ()"
-    note: "Use 'pass'"
-    rhs: pass
+    note: "Use 'stub'"
+    rhs: stub
 - hint:
     lhs: "return ()"
-    note: "Use 'pass'"
-    rhs: pass
+    note: "Use 'stub'"
+    rhs: stub
 - hint:
     lhs: "(: [])"
     note: "Use `one`"
@@ -2667,11 +2667,22 @@
     lhs: sum xs / length xs
     note: "Use `average` from `Relude.Extra.Foldable`"
     rhs: average xs
+
 - hint:
     lhs: "\\a -> (a, a)"
-    note: "Use `dup` from `Relude.Extra.Tuple`"
+    note: "Use `dup`"
     rhs: dup
 
 - warn:
     lhs: "() <$ a"
     rhs: void a
+
+- hint:
+    lhs: "pass"
+    note: "Use 'stub'"
+    rhs: stub
+
+- warn:
+    lhs: "Data.Bool.bool True"
+    rhs: "Use `whenTrue` from HNix Prelude"
+

main/Main.hs

@@ -240,10 +240,10 @@ main' opts@Options{..} = runWithBasicEffectsIO opts execContentsFilesOrRepl
                       liftIO $ Text.putStrLn path
                       when descend $
                         maybe
-                          pass
+                          stub
                           (\case
                             NVSet _ s' -> go (path <> ".") s'
-                            _          -> pass
+                            _          -> stub
                           )
                           mv
               )

main/Repl.hs

@@ -226,7 +226,7 @@ exec update source = do
             -- If the result value is a set, update our context with it
             case val of
               NVSet _ (coerce -> scope) -> put state { replCtx = scope <> replCtx state }
-              _          -> pass
+              _          -> stub
 
           pure $ pure val
         )
@@ -258,7 +258,7 @@ cmd source =
   do
     mVal <- exec True source
     maybe
-      pass
+      stub
       printValue
       mVal
 

src/Nix/Convert.hs

@@ -147,7 +147,7 @@ instance Convertible e t f m
   fromValueMay =
     pure .
       \case
-        NVConstant' NNull -> pass
+        NVConstant' NNull -> stub
         _                 -> mempty
 
   fromValue = fromMayToValue TNull

src/Nix/Utils.hs

@@ -15,10 +15,12 @@ module Nix.Utils
   , trace
   , traceM
   , stub
+  , pass
   , whenTrue
   , list
   , whenText
   , free
+  , whenJust
   , dup
   , mapPair
   , both
@@ -30,7 +32,8 @@ module Nix.Utils
   )
  where
 
-import           Relude                  hiding ( force
+import           Relude                  hiding ( pass
+                                                , force
                                                 , readFile
                                                 , whenJust
                                                 , whenNothing
@@ -66,7 +69,7 @@ trace :: String -> a -> a
 trace = const id
 {-# inline trace #-}
 traceM :: Monad m => String -> m ()
-traceM = const pass
+traceM = const stub
 {-# inline traceM #-}
 #endif
 
@@ -187,6 +190,17 @@ whenTrue =
     mempty
 {-# inline whenTrue #-}
 
+whenJust
+  :: Monoid b
+  => (a -> b)
+  -> Maybe a
+  -> b
+whenJust f ma =
+  maybe
+    mempty
+    f
+    ma
+
 
 -- | Apply a single function to both components of a pair.
 --
@@ -214,6 +228,11 @@ stub :: (Applicative f, Monoid a) => f a
 stub = pure mempty
 {-# inline stub #-}
 
+-- | Alias for @stub@, since @Relude@ has more specialized @pure ()@.
+pass :: (Applicative f) => f ()
+pass = stub
+{-# inline pass #-}
+
 readFile :: Path -> IO Text
 readFile = Text.readFile . coerce
 

src/Nix/Value/Equal.hs

@@ -31,12 +31,12 @@ checkComparable
   -> m ()
 checkComparable x y =
   case (x, y) of
-    (NVConstant (NFloat _), NVConstant (NInt   _)) -> pass
-    (NVConstant (NInt   _), NVConstant (NFloat _)) -> pass
-    (NVConstant (NInt   _), NVConstant (NInt   _)) -> pass
-    (NVConstant (NFloat _), NVConstant (NFloat _)) -> pass
-    (NVStr       _        , NVStr       _        ) -> pass
-    (NVPath      _        , NVPath      _        ) -> pass
+    (NVConstant (NFloat _), NVConstant (NInt   _)) -> stub
+    (NVConstant (NInt   _), NVConstant (NFloat _)) -> stub
+    (NVConstant (NInt   _), NVConstant (NInt   _)) -> stub
+    (NVConstant (NFloat _), NVConstant (NFloat _)) -> stub
+    (NVStr       _        , NVStr       _        ) -> stub
+    (NVPath      _        , NVPath      _        ) -> stub
     _                                              -> throwError $ Comparison x y
 
 -- | Checks whether two containers are equal, using the given item equality

src/Prelude.hs

@@ -9,7 +9,8 @@ module Prelude
     ) where
 
 import           Nix.Utils
-import           Relude                  hiding ( force
+import           Relude                  hiding ( pass
+                                                , force
                                                 , readFile
                                                 , whenJust
                                                 , whenNothing

tests/Main.hs

@@ -70,7 +70,7 @@ ensureNixpkgsCanParse =
             -- Parse and deepseq the resulting expression tree, to ensure the
             -- parser is fully executed.
             _ <- consider (coerce file) (parseNixFileLoc (coerce file)) $ Exc.evaluate . force
-            pass
+            stub
     v -> fail $ "Unexpected parse from default.nix: " <> show v
  where
   getExpr   k m = let Just (Just r) = lookup k m in r

tests/NixLanguageTests.hs

@@ -109,15 +109,15 @@ assertParse _opts file =
     x <- parseNixFileLoc file
     either
       (\ err -> assertFailure $ "Failed to parse " <> coerce file <> ":\n" <> show err)
-      (const pass)  -- pure $! runST $ void $ lint opts expr
+      (const stub)  -- pure $! runST $ void $ lint opts expr
       x
 
 assertParseFail :: Options -> Path -> Assertion
 assertParseFail opts file = do
   eres <- parseNixFileLoc file
-  (`catch` \(_ :: SomeException) -> pass)
+  (`catch` \(_ :: SomeException) -> stub)
     (either
-      (const pass)
+      (const stub)
       (\ expr ->
         do
           _ <- pure $! runST $ void $ lint opts expr
@@ -147,8 +147,8 @@ assertEval _opts files =
       []                 -> void $ hnixEvalFile opts (name <> ".nix")
       [".exp"          ]  -> assertLangOk    opts name
       [".exp.xml"      ]  -> assertLangOkXml opts name
-      [".exp.disabled" ]  -> pass
-      [".exp-disabled" ]  -> pass
+      [".exp.disabled" ]  -> stub
+      [".exp-disabled" ]  -> stub
       [".exp", ".flags"] ->
         do
           liftIO $ setEnv "NIX_PATH" "lang/dir4:lang/dir5"
@@ -177,7 +177,7 @@ assertEval _opts files =
   fixup []                          = mempty
 
 assertEvalFail :: Path -> Assertion
-assertEvalFail file = (`catch` (\(_ :: SomeException) -> pass)) $ do
+assertEvalFail file = (`catch` (\(_ :: SomeException) -> stub)) $ do
   time       <- liftIO getCurrentTime
   evalResult <- printNix <$> hnixEvalFile (defaultOptions time) file
   evalResult `seq` assertFailure $ "File: ''" <> coerce file <> "'' should not evaluate.\nThe evaluation result was `" <> evalResult <> "`."

tests/ParserTests.hs

@@ -740,7 +740,7 @@ assertParseFile file expected =
 assertParseFail :: NixLang -> Assertion
 assertParseFail str =
   either
-    (const pass)
+    (const stub)
     (\ r ->
       assertFailure $ toString $ "\nUnexpected success parsing string ''" <> str <> "'':\n''Parsed value: ''" <> show r <> "''."
     )