Merge pull request #5972 from commercialhaskell/imports

Add explicit import lists

Author: mpilgrem

src/Options/Applicative/Args.hs

@@ -4,35 +4,40 @@
 -- | Accepting arguments to be passed through to a sub-process.
 
 module Options.Applicative.Args
-    (argsArgument
-    ,argsOption
-    ,cmdOption)
-    where
+  ( argsArgument
+  , argsOption
+  , cmdOption
+  ) where
 
-import           Data.Attoparsec.Args
+import           Data.Attoparsec.Args ( EscapingMode (..), parseArgsFromString )
 import qualified Options.Applicative as O
 import           Stack.Prelude
 
--- | An argument which accepts a list of arguments e.g. @--ghc-options="-X P.hs \"this\""@.
+-- | An argument which accepts a list of arguments
+-- e.g. @--ghc-options="-X P.hs \"this\""@.
 argsArgument :: O.Mod O.ArgumentFields [String] -> O.Parser [String]
 argsArgument =
-    O.argument
-        (do s <- O.str
-            either O.readerError pure (parseArgsFromString Escaping s))
+  O.argument
+    (do s <- O.str
+        either O.readerError pure (parseArgsFromString Escaping s))
 
--- | An option which accepts a list of arguments e.g. @--ghc-options="-X P.hs \"this\""@.
+-- | An option which accepts a list of arguments
+-- e.g. @--ghc-options="-X P.hs \"this\""@.
 argsOption :: O.Mod O.OptionFields [String] -> O.Parser [String]
 argsOption =
-    O.option
-        (do s <- O.str
-            either O.readerError pure (parseArgsFromString Escaping s))
+  O.option
+    (do s <- O.str
+        either O.readerError pure (parseArgsFromString Escaping s))
 
--- | An option which accepts a command and a list of arguments e.g. @--exec "echo hello world"@
-cmdOption :: O.Mod O.OptionFields (String, [String]) -> O.Parser (String, [String])
+-- | An option which accepts a command and a list of arguments
+-- e.g. @--exec "echo hello world"@
+cmdOption ::
+     O.Mod O.OptionFields (String, [String])
+  -> O.Parser (String, [String])
 cmdOption =
-    O.option
-        (do s <- O.str
-            xs <- either O.readerError pure (parseArgsFromString Escaping s)
-            case xs of
-                [] -> O.readerError "Must provide a command"
-                x:xs' -> pure (x, xs'))
+  O.option
+    (do s <- O.str
+        xs <- either O.readerError pure (parseArgsFromString Escaping s)
+        case xs of
+          [] -> O.readerError "Must provide a command"
+          x:xs' -> pure (x, xs'))

src/Stack/Config/Nix.hs

@@ -5,19 +5,19 @@
 
 -- | Nix configuration
 module Stack.Config.Nix
-       (nixOptsFromMonoid
-       ,nixCompiler
-       ,nixCompilerVersion
-       ) where
+  ( nixCompiler
+  , nixCompilerVersion
+  , nixOptsFromMonoid
+  ) where
 
 import           Control.Monad.Extra ( ifM )
 import qualified Data.Text as T
 import qualified Data.Text.IO as TIO
 import           Distribution.System ( OS (..) )
-import           Stack.Constants
+import           Stack.Constants ( osIsWindows )
 import           Stack.Prelude
-import           Stack.Types.Config
-import           Stack.Types.Nix
+import           Stack.Types.Config ( HasRunner )
+import           Stack.Types.Nix ( NixOpts (..), NixOptsMonoid (..) )
 import           System.Directory ( doesFileExist )
 
 -- | Type representing exceptions thrown by functions exported by the
@@ -42,37 +42,40 @@ instance Exception ConfigNixException where
     ++ "Only GHC is supported by 'stack --nix'."
 
 -- | Interprets NixOptsMonoid options.
-nixOptsFromMonoid
-    :: HasRunner env
-    => NixOptsMonoid
-    -> OS
-    -> RIO env NixOpts
+nixOptsFromMonoid ::
+     HasRunner env
+  => NixOptsMonoid
+  -> OS
+  -> RIO env NixOpts
 nixOptsFromMonoid NixOptsMonoid{..} os = do
-    let defaultPure = case os of
-          OSX -> False
-          _ -> True
-        nixPureShell = fromFirst defaultPure nixMonoidPureShell
-        nixPackages = fromFirst [] nixMonoidPackages
-        nixInitFile = getFirst nixMonoidInitFile
-        nixShellOptions = fromFirst [] nixMonoidShellOptions
-                          ++ prefixAll (T.pack "-I") (fromFirst [] nixMonoidPath)
-        nixAddGCRoots   = fromFirstFalse nixMonoidAddGCRoots
+  let defaultPure = case os of
+        OSX -> False
+        _ -> True
+      nixPureShell = fromFirst defaultPure nixMonoidPureShell
+      nixPackages = fromFirst [] nixMonoidPackages
+      nixInitFile = getFirst nixMonoidInitFile
+      nixShellOptions = fromFirst [] nixMonoidShellOptions
+                        ++ prefixAll (T.pack "-I") (fromFirst [] nixMonoidPath)
+      nixAddGCRoots   = fromFirstFalse nixMonoidAddGCRoots
 
-    -- Enable Nix-mode by default on NixOS, unless Docker-mode was specified
-    osIsNixOS <- isNixOS
-    let nixEnable0 = fromFirst osIsNixOS nixMonoidEnable
+  -- Enable Nix-mode by default on NixOS, unless Docker-mode was specified
+  osIsNixOS <- isNixOS
+  let nixEnable0 = fromFirst osIsNixOS nixMonoidEnable
 
-    nixEnable <- case () of _
-                                | nixEnable0 && osIsWindows -> do
-                                      logInfo "Note: Disabling nix integration, since this is being run in Windows"
-                                      pure False
-                                | otherwise                 -> pure nixEnable0
+  nixEnable <- case () of
+    _
+      | nixEnable0 && osIsWindows -> do
+          logInfo
+            "Note: Disabling nix integration, since this is being run in Windows"
+          pure False
+      | otherwise -> pure nixEnable0
 
-    when (not (null nixPackages) && isJust nixInitFile) $
-       throwIO NixCannotUseShellFileAndPackagesException
-    pure NixOpts{..}
-  where prefixAll p (x:xs) = p : x : prefixAll p xs
-        prefixAll _ _      = []
+  when (not (null nixPackages) && isJust nixInitFile) $
+    throwIO NixCannotUseShellFileAndPackagesException
+  pure NixOpts{..}
+ where
+  prefixAll p (x:xs) = p : x : prefixAll p xs
+  prefixAll _ _      = []
 
 nixCompiler :: WantedCompiler -> Either ConfigNixException T.Text
 nixCompiler compilerVersion =
@@ -112,7 +115,7 @@ nixCompilerVersion compilerVersion =
 
 isNixOS :: MonadIO m => m Bool
 isNixOS = liftIO $ do
-    let fp = "/etc/os-release"
-    ifM (doesFileExist fp)
-        (T.isInfixOf "ID=nixos" <$> TIO.readFile fp)
-        (pure False)
+  let fp = "/etc/os-release"
+  ifM (doesFileExist fp)
+      (T.isInfixOf "ID=nixos" <$> TIO.readFile fp)
+      (pure False)