Follow hlint suggestion: Use tuple-section

Author: philderbeast

.hlint.yaml

@@ -56,9 +56,8 @@
 - ignore: {name: "Use record patterns"} # 16 hints
 - ignore: {name: "Use replicateM_"} # 2 hints
 - ignore: {name: "Use rights"} # 2 hints
-- ignore: {name: "Use tuple-section"} # 28 hints
 - ignore: {name: "Use typeRep"} # 2 hints
-- ignore: {name: "Use unless"} # 23 hints+++++++++
+- ignore: {name: "Use unless"} # 23 hints
 - ignore: {name: "Use unwords"} # 8 hints
 - ignore: {name: "Use void"} # 23 hints
 

Cabal-syntax/src/Distribution/Compat/Lens.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TupleSections #-}
 
 -- | This module provides very basic lens functionality, without extra dependencies.
 --
@@ -154,7 +155,7 @@ lens sa sbt afb s = sbt s <$> afb (sa s)
 -------------------------------------------------------------------------------
 
 _1 :: Lens (a, c) (b, c) a b
-_1 f (a, c) = flip (,) c <$> f a
+_1 f (a, c) = (,c) <$> f a
 
 _2 :: Lens (c, a) (c, b) a b
 _2 f (c, a) = (,) c <$> f a

Cabal-syntax/src/Distribution/Types/Flag.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE DeriveDataTypeable #-}
 {-# LANGUAGE DeriveGeneric #-}
 {-# LANGUAGE GeneralizedNewtypeDeriving #-}
+{-# LANGUAGE TupleSections #-}
 
 module Distribution.Types.Flag
   ( -- * Package flag
@@ -170,7 +171,7 @@ mkFlagAssignment :: [(FlagName, Bool)] -> FlagAssignment
 mkFlagAssignment =
   FlagAssignment
     . Map.fromListWith (flip combineFlagValues)
-    . fmap (fmap (\b -> (1, b)))
+    . fmap (fmap (1,))
 
 -- | Deconstruct a 'FlagAssignment' into a list of flag/value pairs.
 --

Cabal/src/Distribution/Backpack/ReadyComponent.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE PatternGuards #-}
+{-# LANGUAGE TupleSections #-}
 {-# LANGUAGE TypeFamilies #-}
 
 -- | See <https://github.com/ezyang/ghc-proposals/blob/backpack/proposals/0000-backpack.rst>
@@ -210,7 +211,7 @@ instance Functor InstM where
      in (f x, s')
 
 instance Applicative InstM where
-  pure a = InstM $ \s -> (a, s)
+  pure a = InstM (a,)
   InstM f <*> InstM x = InstM $ \s ->
     let (f', s') = f s
         (x', s'') = x s'

Cabal/src/Distribution/PackageDescription/Check/Conditional.hs

@@ -1,4 +1,5 @@
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections #-}
 
 -- |
 -- Module      :  Distribution.PackageDescription.Check.Conditional
@@ -245,7 +246,7 @@ checkDuplicateModules pkg =
           libMap =
             foldCondTree
               Map.empty
-              (\(_, v) -> Map.fromListWith sumPair . map (\x -> (x, (1, 1))) $ getModules v)
+              (\(_, v) -> Map.fromListWith sumPair . map (,(1, 1)) $ getModules v)
               (Map.unionWith mergePair) -- if a module may occur in nonexclusive branches count it twice strictly and once loosely.
               (Map.unionWith maxPair) -- a module occurs the max of times it might appear in exclusive branches
               t

Cabal/src/Distribution/Simple/Build.hs

@@ -616,7 +616,7 @@ generateCode
   -> IO (SymbolicPath Pkg (Dir Source), [ModuleName.ModuleName])
 generateCode codeGens nm pdesc bi lbi clbi verbosity = do
   when (not . null $ codeGens) $ createDirectoryIfMissingVerbose verbosity True $ i tgtDir
-  (\x -> (tgtDir, x)) . concat <$> mapM go codeGens
+  (tgtDir,) . concat <$> mapM go codeGens
   where
     allLibs = (maybe id (:) $ library pdesc) (subLibraries pdesc)
     dependencyLibs = filter (const True) allLibs -- intersect with componentPackageDeps of clbi

Cabal/src/Distribution/Simple/BuildPaths.hs

@@ -1,6 +1,7 @@
 {-# LANGUAGE DataKinds #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TupleSections #-}
 
 -----------------------------------------------------------------------------
 
@@ -321,7 +322,7 @@ getSourceFiles
   -> [ModuleName.ModuleName]
   -> IO [(ModuleName.ModuleName, SymbolicPathX allowAbsolute Pkg File)]
 getSourceFiles verbosity mbWorkDir dirs modules = for modules $ \m ->
-  fmap ((,) m) $
+  fmap (m,) $
     findFileCwdWithExtension
       mbWorkDir
       builtinHaskellSuffixes

Cabal/src/Distribution/Simple/BuildTarget.hs

@@ -3,6 +3,7 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE TupleSections #-}
 
 -----------------------------------------------------------------------------
 
@@ -229,12 +230,12 @@ readUserBuildTarget targetstr =
 
     tokens :: CabalParsing m => m (String, Maybe (String, Maybe String))
     tokens =
-      (\s -> (s, Nothing)) <$> parsecHaskellString
+      (,Nothing) <$> parsecHaskellString
         <|> (,) <$> token <*> P.optional (P.char ':' *> tokens2)
 
     tokens2 :: CabalParsing m => m (String, Maybe String)
     tokens2 =
-      (\s -> (s, Nothing)) <$> parsecHaskellString
+      (,Nothing) <$> parsecHaskellString
         <|> (,) <$> token <*> P.optional (P.char ':' *> (parsecHaskellString <|> token))
 
     token :: CabalParsing m => m String

Cabal/src/Distribution/Simple/Configure.hs

@@ -5,6 +5,7 @@
 {-# LANGUAGE RankNTypes #-}
 {-# LANGUAGE RecordWildCards #-}
 {-# LANGUAGE ScopedTypeVariables #-}
+{-# LANGUAGE TupleSections #-}
 
 -----------------------------------------------------------------------------
 
@@ -1679,7 +1680,7 @@ configureDependencies
         (failedDeps, allPkgDeps) =
           partitionEithers $
             concat
-              [ fmap (\s -> (dep, s)) <$> status
+              [ fmap (dep,) <$> status
               | dep <- enabledBuildDepends pkg_descr enableSpec
               , let status =
                       selectDependency

Cabal/src/Distribution/ZinzaPrelude.hs

@@ -1,3 +1,5 @@
+{-# LANGUAGE TupleSections #-}
+
 -- | A small prelude used in @zinza@ generated
 -- template modules.
 module Distribution.ZinzaPrelude
@@ -27,7 +29,7 @@ instance Functor Writer where
   fmap = liftM
 
 instance Applicative Writer where
-  pure x = W $ \ss -> (ss, x)
+  pure x = W (,x)
   (<*>) = ap
 
 instance Monad Writer where