Reformat foldOnGhcPkgId'

Author: mpilgrem

src/Stack/Build/Cache.hs

@@ -397,13 +397,17 @@ writePrecompiledCache
             libPath <- pathFromPkgId stackRootRelative ghcPkgId
             pc <- pcAction
             pure $ case libName of
-              Nothing -> pc{library = Just libPath}
-              _ -> pc{subLibs = libPath : pc.subLibs}
-      precompiled <- foldOnGhcPkgId' installedLibToPath mghcPkgId (pure PrecompiledCache
+              Nothing -> pc { library = Just libPath }
+              _ -> pc { subLibs = libPath : pc.subLibs }
+      precompiled <- foldOnGhcPkgId'
+        installedLibToPath
+        mghcPkgId
+        ( pure PrecompiledCache
             { library = Nothing
             , subLibs = []
             , exes = exes'
-            })
+            }
+        )
       savePrecompiledCache key precompiled
       -- reuse precompiled cache with haddocks also in case when haddocks are
       -- not required

src/Stack/Build/ExecutePackage.hs

@@ -101,7 +101,7 @@ import           Stack.Types.BuildOpts
 import           Stack.Types.BuildOptsCLI ( BuildOptsCLI (..) )
 import           Stack.Types.CompCollection
                    ( collectionKeyValueList, collectionLookup
-                   , getBuildableListText, foldComponentToAnotherCollection
+                   , foldComponentToAnotherCollection, getBuildableListText
                    )
 import           Stack.Types.Compiler
                    ( ActualCompiler (..), WhichCompiler (..), getGhcVersion
@@ -637,11 +637,22 @@ singleBuild
       when (hasLibrary || hasSubLibraries) $ cabal KeepTHLoading ["register"]
 
     copyDdumpFilesIfNeeded buildingFinals ee.buildOpts.ddumpDir
-    installedPkg <- fetchAndMarkInstalledPackage ee (taskLocation task) package pkgId
-    postProcessRemotePackage task.taskType ac cache ee installedPkg package pkgId pkgDir
+    installedPkg <-
+      fetchAndMarkInstalledPackage ee (taskLocation task) package pkgId
+    postProcessRemotePackage
+      task.taskType
+      ac
+      cache
+      ee
+      installedPkg
+      package
+      pkgId
+      pkgDir
     pure installedPkg
 
-postProcessRemotePackage :: (HasEnvConfig env)
+-- | Action in the case that the task relates to a remote package.
+postProcessRemotePackage ::
+     (HasEnvConfig env)
   => TaskType
   -> ActionContext
   -> ConfigCache
@@ -651,64 +662,77 @@ postProcessRemotePackage :: (HasEnvConfig env)
   -> PackageIdentifier
   -> Path b Dir
   -> RIO env ()
-postProcessRemotePackage taskType ac cache ee installedPackage package pkgId pkgDir = do
-  case taskType of
-    TTRemotePackage isMutable _ loc -> do
-      when (isMutable == Immutable) $ writePrecompiledCache
-        ee.baseConfigOpts
-        loc
-        cache.configureOpts
-        cache.buildHaddocks
-        installedPackage
-        (buildableExes package)
-      -- For packages from a package index, pkgDir is in the tmp directory. We
-      -- eagerly delete it if no other tasks require it, to reduce space usage
-      -- in tmp (#3018).
-      let remaining =
-            Set.filter
-              (\(ActionId x _) -> x == pkgId)
-              ac.remaining
-      when (null remaining) $ removeDirRecur pkgDir
-    _ -> pure ()
-
--- | Once all the cabal related tasks have run for a package, we should be able to gather
--- the information needed to create an @Installed@ package value.
--- For now, either there's a main library in which case we consider the package's libraries
--- ghcPkgIds or we just consider it's an executable
+postProcessRemotePackage
+    taskType
+    ac
+    cache
+    ee
+    installedPackage
+    package
+    pkgId
+    pkgDir
+  = case taskType of
+      TTRemotePackage isMutable _ loc -> do
+        when (isMutable == Immutable) $ writePrecompiledCache
+          ee.baseConfigOpts
+          loc
+          cache.configureOpts
+          cache.buildHaddocks
+          installedPackage
+          (buildableExes package)
+        -- For packages from a package index, pkgDir is in the tmp directory. We
+        -- eagerly delete it if no other tasks require it, to reduce space usage
+        -- in tmp (#3018).
+        let remaining =
+              Set.filter
+                (\(ActionId x _) -> x == pkgId)
+                ac.remaining
+        when (null remaining) $ removeDirRecur pkgDir
+      _ -> pure ()
+
+-- | Once all the Cabal-related tasks have run for a package, we should be able
+-- to gather the information needed to create an 'Installed' package value. For
+-- now, either there's a main library (in which case we consider the 'GhcPkgId'
+-- values of the package's libraries) or we just consider it's an executable
 -- (and mark all the executables as installed, if any).
 --
--- Note that this also modifies the installedDumpPkgsTVar which is used for generating Haddocks.
+-- Note that this also modifies the installedDumpPkgsTVar which is used for
+-- generating Haddocks.
 --
 fetchAndMarkInstalledPackage ::
-  (HasTerm env, HasEnvConfig env)
+     (HasTerm env, HasEnvConfig env)
   => ExecuteEnv
   -> InstallLocation
   -> Package
   -> PackageIdentifier
   -> RIO env Installed
 fetchAndMarkInstalledPackage ee taskInstallLocation package pkgId = do
   let baseConfigOpts = ee.baseConfigOpts
-  let (installedPkgDb, installedDumpPkgsTVar) =
+      (installedPkgDb, installedDumpPkgsTVar) =
         case taskInstallLocation of
           Snap ->
             ( baseConfigOpts.snapDB
             , ee.snapshotDumpPkgs )
           Local ->
             ( baseConfigOpts.localDB
             , ee.localDumpPkgs )
-  -- let ident = PackageIdentifier package.name package.version
-  -- only pure the sub-libraries to cache them if we also cache the main
+  -- Only pure the sub-libraries to cache them if we also cache the main
   -- library (that is, if it exists)
   if hasBuildableMainLibrary package
     then do
-      let getAndStoreGhcPkgId = loadInstalledPkg [installedPkgDb] installedDumpPkgsTVar
-      let foldSubLibToMap subLib mapInMonad = do
+      let getAndStoreGhcPkgId =
+            loadInstalledPkg [installedPkgDb] installedDumpPkgsTVar
+          foldSubLibToMap subLib mapInMonad = do
             let mungedName = toCabalMungedPackageName package.name subLib.name
-            maybeGhcpkgId <- getAndStoreGhcPkgId (encodeCompatPackageName mungedName)
+            maybeGhcpkgId <-
+              getAndStoreGhcPkgId (encodeCompatPackageName mungedName)
             mapInMonad <&> case maybeGhcpkgId of
               Just v -> Map.insert subLib.name v
               _ -> id
-      subLibsPkgIds <- foldComponentToAnotherCollection package.subLibraries foldSubLibToMap mempty
+      subLibsPkgIds <- foldComponentToAnotherCollection
+        package.subLibraries
+        foldSubLibToMap
+        mempty
       mGhcPkgId <- getAndStoreGhcPkgId package.name
       case mGhcPkgId of
         Nothing -> throwM $ Couldn'tFindPkgId package.name

src/Stack/Types/CompCollection.hs

@@ -30,13 +30,13 @@ module Stack.Types.CompCollection
   , foldComponentToAnotherCollection
   ) where
 
+import qualified Data.Map as M
 import qualified Data.Set as Set
 import           Stack.Prelude
 import           Stack.Types.Component
                    ( HasBuildInfo, HasName, StackBuildInfo (..)
                    , StackUnqualCompName (..)
                    )
-import qualified Data.Map as M
 
 -- | A type representing collections of components, distinguishing buildable
 -- components and non-buildable components.
@@ -66,10 +66,11 @@ instance Foldable CompCollection where
   foldr' fn c collection = M.foldr' fn c collection.buildableOnes
   null = M.null . (.buildableOnes)
 
--- | While the @HashMap@ is a more suitable choice for @Text@ based keys in general 
--- (it scales better), constant factors are largely dominant for maps with less than
--- 1000 keys. Package with more than 100 components are extremely unlikely, so we keep
--- a simple @Map@.
+-- | The 'Data.HashMap.Strict.HashMap' type is a more suitable choice than 'Map'
+-- for 'Data.Text.Text' based keys in general (it scales better). However,
+-- constant factors are largely dominant for maps with less than 1000 keys.
+-- Packages with more than 100 components are extremely unlikely, so we use a
+-- 'Map'.
 type InnerCollection component = Map StackUnqualCompName component
 
 -- | A function to add a component to a collection of components. Ensures that

src/Stack/Types/Installed.hs

@@ -134,12 +134,18 @@ installedPackageIdentifier :: Installed -> PackageIdentifier
 installedPackageIdentifier (Library pid _) = pid
 installedPackageIdentifier (Executable pid) = pid
 
--- | A strict fold over the @GhcPkgId@ of the given installed package.
--- This will iterate on both sub and main librarie(s) if any.
-foldOnGhcPkgId' :: (Maybe StackUnqualCompName -> GhcPkgId -> resT -> resT) -> Installed -> resT -> resT
+-- | A strict fold over the 'GhcPkgId' of the given installed package. This will
+-- iterate on both sub and main libraries, if any.
+foldOnGhcPkgId' ::
+     (Maybe StackUnqualCompName -> GhcPkgId -> resT -> resT)
+  -> Installed
+  -> resT
+  -> resT
 foldOnGhcPkgId' _ Executable{} res = res
-foldOnGhcPkgId' fn (Library _ libInfo) res = M.foldrWithKey' (fn . Just) (base res) libInfo.subLib
-  where base = fn Nothing libInfo.ghcPkgId
+foldOnGhcPkgId' fn (Library _ libInfo) res =
+  M.foldrWithKey' (fn . Just) (base res) libInfo.subLib
+ where
+  base = fn Nothing libInfo.ghcPkgId
 
 -- | Get the installed Version.
 installedVersion :: Installed -> Version