Merge pull request #11825 from cabalism/hlint/suggest-nub-alternatives

Hlint: suggest nub alternative

Author: mergify[bot]

.hlint.yaml

@@ -37,6 +37,10 @@
 - ignore: {name: "Use fmap", within: [Distribution.Client.HttpUtils, Distribution.Simple.SrcDist]}
 - ignore: {name: "Use fold", within: [Test.Laws]}
 
+# For lists in these rules we use single letter variables like x rather than xs,
+# because "hlint considers only single-letter identifiers as rules' variables.
+# Anything longer will match literally".
+# SEE: https://github.com/ndmitchell/hlint/issues/1612
 - group:
     name: cabal-suggestions
     enabled: true
@@ -45,6 +49,14 @@
         lhs: fromMaybe x (Data.Map.lookup k m)
         rhs: Map.findWithDefault x k m
         name: Use findWithDefault
+    - hint:
+        lhs: nub x
+        rhs: ordNub x
+        name: Use ordNub
+        note: |
+            The growth rate of nub is O(n^2) and for ordNub it is O(n log n).  May require adding import of either;
+              - Distribution.Utils.Generic from Cabal-syntax, or
+              - Distribution.Simple.Utils from Cabal.
 
 - arguments:
     - --ignore-glob=Cabal-syntax/src/Distribution/Fields/Lexer.hs

Cabal-syntax/src/Distribution/PackageDescription/FieldGrammar.hs

@@ -88,6 +88,7 @@ import qualified Data.ByteString.Char8 as BS8
 import qualified Distribution.Compat.CharParsing as P
 import qualified Distribution.SPDX as SPDX
 import qualified Distribution.Types.Lens as L
+import Distribution.Utils.Generic (ordNub)
 
 -------------------------------------------------------------------------------
 -- PackageDescription
@@ -901,7 +902,7 @@ _syntaxFieldNames =
   sequence_
     [ BS8.putStrLn $ " \\ " <> n
     | n <-
-        nub $
+        ordNub $
           sort $
             mconcat
               [ fieldGrammarKnownFieldList packageDescriptionFieldGrammar
@@ -927,7 +928,7 @@ _syntaxExtensions =
     ]
   where
     es =
-      nub $
+      ordNub $
         sort
           [ prettyShow e
           | e <- [minBound .. maxBound]

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

@@ -28,6 +28,7 @@ import Distribution.Utils.Path
 
 import Distribution.Compiler
 import Distribution.ModuleName
+import Distribution.Utils.Generic (ordNub)
 import Language.Haskell.Extension
 
 -- Consider refactoring into executable and library versions.
@@ -260,7 +261,7 @@ instance Semigroup BuildInfo where
       }
     where
       combine field = field a `mappend` field b
-      combineNub field = nub (combine field)
+      combineNub field = ordNub (combine field)
       combineMby field = field b `mplus` field a
 
 emptyBuildInfo :: BuildInfo

Cabal-tests/tests/UnitTests/Distribution/PackageDescription/Check.hs

@@ -7,6 +7,7 @@ import Distribution.Compat.Prelude
 import Prelude ()
 
 import Distribution.PackageDescription.Check
+import Distribution.Simple.Utils (ordNub)
 
 import Test.Tasty
 import Test.Tasty.HUnit
@@ -26,7 +27,7 @@ tests =
     allExplanationIdStrings = map ppCheckExplanationId [minBound..maxBound]
 
     uniqueNames :: Bool
-    uniqueNames = length allExplanationIdStrings == length (nub allExplanationIdStrings)
+    uniqueNames = length allExplanationIdStrings == length (ordNub allExplanationIdStrings)
 
     longerThan :: [CheckExplanationIDString]
     longerThan = filter ((>25). length) allExplanationIdStrings

Cabal-tests/tests/UnitTests/Distribution/Utils/NubList.hs

@@ -8,6 +8,7 @@ import Prelude ()
 import Distribution.Compat.Prelude.Internal
 
 import Distribution.Utils.NubList
+import Distribution.Simple.Utils (ordNub)
 import Test.Tasty
 import Test.Tasty.HUnit
 import Test.Tasty.QuickCheck
@@ -46,25 +47,25 @@ prop_Ordering :: [Int] -> Property
 prop_Ordering xs =
     mempty <> toNubList xs' === toNubList xs' <> mempty
   where
-    xs' = nub xs
+    xs' = ordNub xs
 
 prop_DeDupe :: [Int] -> Property
 prop_DeDupe xs =
     fromNubList (toNubList (xs' ++ xs)) === xs' -- Note, we append primeless xs
   where
-    xs' = nub xs
+    xs' = ordNub xs
 
 prop_DeDupeR :: [Int] -> Property
 prop_DeDupeR xs =
     fromNubListR (toNubListR (xs ++ xs')) === xs' -- Note, we prepend primeless xs
   where
-    xs' = nub xs
+    xs' = ordNub xs
 
 prop_Nub :: [Int] -> Property
 prop_Nub xs = rhs === lhs
   where
     rhs = fromNubList (toNubList xs)
-    lhs = nub xs
+    lhs = ordNub xs
 
 prop_Identity :: [Int] -> Bool
 prop_Identity xs =

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

@@ -26,6 +26,7 @@ import Distribution.Compat.NonEmptySet (toNonEmpty)
 import Distribution.Package
 import Distribution.PackageDescription
 import Distribution.PackageDescription.Check.Monad
+import Distribution.Simple.Utils (ordNub)
 import Distribution.Utils.Generic (isAscii)
 import Distribution.Version
 
@@ -80,7 +81,7 @@ partitionDeps ads ns ds = do
     -- shared targets that match
     fads = filter (flip elem dqs . fst) ads
     -- the names of such targets
-    inName = nub $ map fst fads :: [UnqualComponentName]
+    inName = ordNub $ map fst fads :: [UnqualComponentName]
     -- the dependencies of such targets
     inDep = concatMap snd fads :: [Dependency]
 

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

@@ -559,8 +559,8 @@ checkBuildInfoFeatures bi sv = do
 checkBuildInfoExtensions :: Monad m => BuildInfo -> CheckM m ()
 checkBuildInfoExtensions bi = do
   let exts = allExtensions bi
-      extCabal1_2 = nub $ filter (`elem` compatExtensionsExtra) exts
-      extCabal1_4 = nub $ filter (`notElem` compatExtensions) exts
+      extCabal1_2 = ordNub $ filter (`elem` compatExtensionsExtra) exts
+      extCabal1_4 = ordNub $ filter (`notElem` compatExtensions) exts
   -- As of Cabal-1.4 we can add new extensions without worrying
   -- about breaking old versions of cabal.
   checkSpecVer

Cabal/src/Distribution/Simple.hs

@@ -824,8 +824,8 @@ sanityCheckHookedBuildInfo verbosity pkg_descr (_, hookExes)
   | exe1 : _ <- nonExistent =
       dieWithException verbosity $ SanityCheckHookedBuildInfo exe1
   where
-    pkgExeNames = nub (map exeName (executables pkg_descr))
-    hookExeNames = nub (map fst hookExes)
+    pkgExeNames = ordNub (map exeName (executables pkg_descr))
+    hookExeNames = ordNub (map fst hookExes)
     nonExistent = hookExeNames \\ pkgExeNames
 sanityCheckHookedBuildInfo _ _ _ = return ()
 

Cabal/src/Distribution/Simple/BuildTarget.hs

@@ -3,6 +3,7 @@
 {-# LANGUAGE DuplicateRecordFields #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE StandaloneDeriving #-}
 {-# LANGUAGE TupleSections #-}
 
 -----------------------------------------------------------------------------
@@ -132,6 +133,9 @@ data BuildTarget
     BuildTargetFile ComponentName FilePath
   deriving (Eq, Show, Generic)
 
+-- | @since 3.18
+deriving instance Ord BuildTarget
+
 instance Binary BuildTarget
 
 buildTargetComponentName :: BuildTarget -> ComponentName
@@ -855,6 +859,9 @@ data MatchError
   | MatchErrorNoSuch String String
   deriving (Show, Eq)
 
+-- | @since 3.18
+deriving instance Ord MatchError
+
 instance Alternative Match where
   empty = mzero
   (<|>) = mplus
@@ -943,13 +950,13 @@ increaseConfidence = ExactMatch 1 [()]
 increaseConfidenceFor :: Match a -> Match a
 increaseConfidenceFor m = m >>= \r -> increaseConfidence >> return r
 
-nubMatches :: Eq a => Match a -> Match a
+nubMatches :: Ord a => Match a -> Match a
 nubMatches (NoMatch d msgs) = NoMatch d msgs
-nubMatches (ExactMatch d xs) = ExactMatch d (nub xs)
-nubMatches (InexactMatch d xs) = InexactMatch d (nub xs)
+nubMatches (ExactMatch d xs) = ExactMatch d (ordNub xs)
+nubMatches (InexactMatch d xs) = InexactMatch d (ordNub xs)
 
 nubMatchErrors :: Match a -> Match a
-nubMatchErrors (NoMatch d msgs) = NoMatch d (nub msgs)
+nubMatchErrors (NoMatch d msgs) = NoMatch d (ordNub msgs)
 nubMatchErrors (ExactMatch d xs) = ExactMatch d xs
 nubMatchErrors (InexactMatch d xs) = InexactMatch d xs
 
@@ -970,14 +977,14 @@ tryEach = exactMatches
 -- | Given a matcher and a key to look up, use the matcher to find all the
 -- possible matches. There may be 'None', a single 'Unambiguous' match or
 -- you may have an 'Ambiguous' match with several possibilities.
-findMatch :: Eq b => Match b -> MaybeAmbiguous b
+findMatch :: Ord b => Match b -> MaybeAmbiguous b
 findMatch match =
   case match of
-    NoMatch _ msgs -> None (nub msgs)
+    NoMatch _ msgs -> None (ordNub msgs)
     ExactMatch _ xs -> checkAmbiguous xs
     InexactMatch _ xs -> checkAmbiguous xs
   where
-    checkAmbiguous xs = case nub xs of
+    checkAmbiguous xs = case ordNub xs of
       [x] -> Unambiguous x
       xs' -> Ambiguous xs'
 

Cabal/src/Distribution/Simple/Configure.hs

@@ -1369,14 +1369,14 @@ finalCheckPackage
       -- Check languages and extensions
       -- TODO: Move this into a helper function.
       let langlist =
-            nub $
+            ordNub $
               mapMaybe defaultLanguage (enabledBuildInfos pkg_descr enabled)
       let langs = unsupportedLanguages comp langlist
       unless (null langs) $
         dieWithException verbosity $
           UnsupportedLanguages (packageId pkg_descr) (compilerId comp) (map prettyShow langs)
       let extlist =
-            nub $
+            ordNub $
               concatMap
                 allExtensions
                 (enabledBuildInfos pkg_descr enabled)
@@ -2607,7 +2607,7 @@ configurePkgconfigPackages verbosity pkg_descr progdb enabled
     pkgconfigBuildInfo :: [PkgconfigDependency] -> IO BuildInfo
     pkgconfigBuildInfo [] = return mempty
     pkgconfigBuildInfo pkgdeps = do
-      let pkgs = nub [prettyShow pkg | PkgconfigDependency pkg _ <- pkgdeps]
+      let pkgs = ordNub [prettyShow pkg | PkgconfigDependency pkg _ <- pkgdeps]
       ccflags <- pkgconfig ("--cflags" : pkgs)
       ldflags <- pkgconfig ("--libs" : pkgs)
       ldflags_static <- pkgconfig ("--libs" : "--static" : pkgs)