Drop support for GHC < 8 (#323)

This prepares u-c for supporting hashable-1.4, as discussed in
#318.

Author: sjakobi

.github/workflows/haskell-ci.yml

@@ -8,9 +8,9 @@
 #
 # For more information, see https://github.com/haskell-CI/haskell-ci
 #
-# version: 0.13.20210525
+# version: 0.13.20211030
 #
-# REGENDATA ("0.13.20210525",["github","--benchmarks-jobs= >=7.10","--installed=-containers","--installed=-binary","unordered-containers.cabal","--branches=master"])
+# REGENDATA ("0.13.20211030",["github","--benchmarks-jobs= >=7.10","--installed=-containers","--installed=-binary","unordered-containers.cabal","--branches=master"])
 #
 name: Haskell-CI
 on:
@@ -31,56 +31,97 @@ jobs:
       matrix:
         include:
           - compiler: ghc-9.0.1
+            compilerKind: ghc
+            compilerVersion: 9.0.1
+            setup-method: hvr-ppa
             allow-failure: false
-          - compiler: ghc-8.10.4
+          - compiler: ghc-8.10.7
+            compilerKind: ghc
+            compilerVersion: 8.10.7
+            setup-method: ghcup
             allow-failure: false
           - compiler: ghc-8.8.4
+            compilerKind: ghc
+            compilerVersion: 8.8.4
+            setup-method: hvr-ppa
             allow-failure: false
           - compiler: ghc-8.6.5
+            compilerKind: ghc
+            compilerVersion: 8.6.5
+            setup-method: hvr-ppa
             allow-failure: false
           - compiler: ghc-8.4.4
+            compilerKind: ghc
+            compilerVersion: 8.4.4
+            setup-method: hvr-ppa
             allow-failure: false
           - compiler: ghc-8.2.2
+            compilerKind: ghc
+            compilerVersion: 8.2.2
+            setup-method: hvr-ppa
             allow-failure: false
           - compiler: ghc-8.0.2
-            allow-failure: false
-          - compiler: ghc-7.10.3
-            allow-failure: false
-          - compiler: ghc-7.8.4
+            compilerKind: ghc
+            compilerVersion: 8.0.2
+            setup-method: hvr-ppa
             allow-failure: false
       fail-fast: false
     steps:
       - name: apt
         run: |
           apt-get update
-          apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common
-          apt-add-repository -y 'ppa:hvr/ghc'
-          apt-get update
-          apt-get install -y $CC cabal-install-3.4
+          apt-get install -y --no-install-recommends gnupg ca-certificates dirmngr curl git software-properties-common libtinfo5
+          if [ "${{ matrix.setup-method }}" = ghcup ]; then
+            mkdir -p "$HOME/.ghcup/bin"
+            curl -sL https://downloads.haskell.org/ghcup/0.1.17.3/x86_64-linux-ghcup-0.1.17.3 > "$HOME/.ghcup/bin/ghcup"
+            chmod a+x "$HOME/.ghcup/bin/ghcup"
+            "$HOME/.ghcup/bin/ghcup" install ghc "$HCVER"
+            "$HOME/.ghcup/bin/ghcup" install cabal 3.6.2.0
+          else
+            apt-add-repository -y 'ppa:hvr/ghc'
+            apt-get update
+            apt-get install -y "$HCNAME"
+            mkdir -p "$HOME/.ghcup/bin"
+            curl -sL https://downloads.haskell.org/ghcup/0.1.17.3/x86_64-linux-ghcup-0.1.17.3 > "$HOME/.ghcup/bin/ghcup"
+            chmod a+x "$HOME/.ghcup/bin/ghcup"
+            "$HOME/.ghcup/bin/ghcup" install cabal 3.6.2.0
+          fi
         env:
-          CC: ${{ matrix.compiler }}
+          HCKIND: ${{ matrix.compilerKind }}
+          HCNAME: ${{ matrix.compiler }}
+          HCVER: ${{ matrix.compilerVersion }}
       - name: Set PATH and environment variables
         run: |
           echo "$HOME/.cabal/bin" >> $GITHUB_PATH
-          echo "LANG=C.UTF-8" >> $GITHUB_ENV
-          echo "CABAL_DIR=$HOME/.cabal" >> $GITHUB_ENV
-          echo "CABAL_CONFIG=$HOME/.cabal/config" >> $GITHUB_ENV
-          HCDIR=$(echo "/opt/$CC" | sed 's/-/\//')
-          HCNAME=ghc
-          HC=$HCDIR/bin/$HCNAME
-          echo "HC=$HC" >> $GITHUB_ENV
-          echo "HCPKG=$HCDIR/bin/$HCNAME-pkg" >> $GITHUB_ENV
-          echo "HADDOCK=$HCDIR/bin/haddock" >> $GITHUB_ENV
-          echo "CABAL=/opt/cabal/3.4/bin/cabal -vnormal+nowrap" >> $GITHUB_ENV
+          echo "LANG=C.UTF-8" >> "$GITHUB_ENV"
+          echo "CABAL_DIR=$HOME/.cabal" >> "$GITHUB_ENV"
+          echo "CABAL_CONFIG=$HOME/.cabal/config" >> "$GITHUB_ENV"
+          HCDIR=/opt/$HCKIND/$HCVER
+          if [ "${{ matrix.setup-method }}" = ghcup ]; then
+            HC=$HOME/.ghcup/bin/$HCKIND-$HCVER
+            echo "HC=$HC" >> "$GITHUB_ENV"
+            echo "HCPKG=$HOME/.ghcup/bin/$HCKIND-pkg-$HCVER" >> "$GITHUB_ENV"
+            echo "HADDOCK=$HOME/.ghcup/bin/haddock-$HCVER" >> "$GITHUB_ENV"
+            echo "CABAL=$HOME/.ghcup/bin/cabal-3.6.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"
+          else
+            HC=$HCDIR/bin/$HCKIND
+            echo "HC=$HC" >> "$GITHUB_ENV"
+            echo "HCPKG=$HCDIR/bin/$HCKIND-pkg" >> "$GITHUB_ENV"
+            echo "HADDOCK=$HCDIR/bin/haddock" >> "$GITHUB_ENV"
+            echo "CABAL=$HOME/.ghcup/bin/cabal-3.6.2.0 -vnormal+nowrap" >> "$GITHUB_ENV"
+          fi
+
           HCNUMVER=$(${HC} --numeric-version|perl -ne '/^(\d+)\.(\d+)\.(\d+)(\.(\d+))?$/; print(10000 * $1 + 100 * $2 + ($3 == 0 ? $5 != 1 : $3))')
-          echo "HCNUMVER=$HCNUMVER" >> $GITHUB_ENV
-          echo "ARG_TESTS=--enable-tests" >> $GITHUB_ENV
-          if [ $((HCNUMVER >= 71000)) -ne 0 ] ; then echo "ARG_BENCH=--enable-benchmarks" >> $GITHUB_ENV ; else echo "ARG_BENCH=--disable-benchmarks" >> $GITHUB_ENV ; fi
-          echo "HEADHACKAGE=false" >> $GITHUB_ENV
-          echo "ARG_COMPILER=--$HCNAME --with-compiler=$HC" >> $GITHUB_ENV
-          echo "GHCJSARITH=0" >> $GITHUB_ENV
+          echo "HCNUMVER=$HCNUMVER" >> "$GITHUB_ENV"
+          echo "ARG_TESTS=--enable-tests" >> "$GITHUB_ENV"
+          echo "ARG_BENCH=--enable-benchmarks" >> "$GITHUB_ENV"
+          echo "HEADHACKAGE=false" >> "$GITHUB_ENV"
+          echo "ARG_COMPILER=--$HCKIND --with-compiler=$HC" >> "$GITHUB_ENV"
+          echo "GHCJSARITH=0" >> "$GITHUB_ENV"
         env:
-          CC: ${{ matrix.compiler }}
+          HCKIND: ${{ matrix.compilerKind }}
+          HCNAME: ${{ matrix.compiler }}
+          HCVER: ${{ matrix.compilerVersion }}
       - name: env
         run: |
           env
@@ -141,7 +182,8 @@ jobs:
       - name: generate cabal.project
         run: |
           PKGDIR_unordered_containers="$(find "$GITHUB_WORKSPACE/unpacked" -maxdepth 1 -type d -regex '.*/unordered-containers-[0-9.]*')"
-          echo "PKGDIR_unordered_containers=${PKGDIR_unordered_containers}" >> $GITHUB_ENV
+          echo "PKGDIR_unordered_containers=${PKGDIR_unordered_containers}" >> "$GITHUB_ENV"
+          rm -f cabal.project cabal.project.local
           touch cabal.project
           touch cabal.project.local
           echo "packages: ${PKGDIR_unordered_containers}" >> cabal.project

Data/HashMap/Internal.hs

@@ -137,17 +137,11 @@ module Data.HashMap.Internal
     , adjust#
     ) where
 
-#if __GLASGOW_HASKELL__ < 710
-import Control.Applicative ((<$>), Applicative(pure))
-import Data.Monoid (Monoid(mempty, mappend))
-import Data.Traversable (Traversable(..))
-import Data.Word (Word)
-#endif
-#if __GLASGOW_HASKELL__ >= 711
+#if !MIN_VERSION_base(4,11,0)
 import Data.Semigroup (Semigroup((<>)))
 #endif
 import Control.DeepSeq (NFData(rnf))
-import Control.Monad.ST (ST)
+import Control.Monad.ST (ST, runST)
 import Data.Bits ((.&.), (.|.), complement, popCount, unsafeShiftL, unsafeShiftR)
 import Data.Data hiding (Typeable)
 import qualified Data.Foldable as Foldable
@@ -162,17 +156,14 @@ import Text.Read hiding (step)
 import qualified Data.HashMap.Internal.Array as A
 import qualified Data.Hashable as H
 import Data.Hashable (Hashable)
-import Data.HashMap.Internal.Unsafe (runST)
 import Data.HashMap.Internal.List (isPermutationBy, unorderedCompare)
 import Data.Typeable (Typeable)
 
 import GHC.Exts (isTrue#)
 import qualified GHC.Exts as Exts
 
-#if MIN_VERSION_base(4,9,0)
 import Data.Functor.Classes
 import GHC.Stack
-#endif
 
 #if MIN_VERSION_hashable(1,2,5)
 import qualified Data.Hashable.Lifted as H
@@ -186,9 +177,7 @@ import qualified Control.DeepSeq as NF
 import GHC.Exts (TYPE, Int (..), Int#)
 #endif
 
-#if MIN_VERSION_base(4,8,0)
 import Data.Functor.Identity (Identity (..))
-#endif
 import Control.Applicative (Const (..))
 import Data.Coerce (coerce)
 
@@ -265,12 +254,10 @@ instance Foldable.Foldable (HashMap k) where
     {-# INLINE foldr' #-}
     foldl' = foldl'
     {-# INLINE foldl' #-}
-#if MIN_VERSION_base(4,8,0)
     null = null
     {-# INLINE null #-}
     length = size
     {-# INLINE length #-}
-#endif
 
 #if MIN_VERSION_base(4,10,0)
 -- | @since 0.2.11
@@ -283,7 +270,6 @@ instance Bifoldable HashMap where
     {-# INLINE bifoldl #-}
 #endif
 
-#if __GLASGOW_HASKELL__ >= 711
 -- | '<>' = 'union'
 --
 -- If a key occurs in both maps, the mapping from the first will be the mapping in the result.
@@ -295,7 +281,6 @@ instance Bifoldable HashMap where
 instance (Eq k, Hashable k) => Semigroup (HashMap k v) where
   (<>) = union
   {-# INLINE (<>) #-}
-#endif
 
 -- | 'mempty' = 'empty'
 --
@@ -310,11 +295,7 @@ instance (Eq k, Hashable k) => Semigroup (HashMap k v) where
 instance (Eq k, Hashable k) => Monoid (HashMap k v) where
   mempty = empty
   {-# INLINE mempty #-}
-#if __GLASGOW_HASKELL__ >= 711
   mappend = (<>)
-#else
-  mappend = union
-#endif
   {-# INLINE mappend #-}
 
 instance (Data k, Data v, Eq k, Hashable k) => Data (HashMap k v) where
@@ -336,7 +317,6 @@ type Hash   = Word
 type Bitmap = Word
 type Shift  = Int
 
-#if MIN_VERSION_base(4,9,0)
 instance Show2 HashMap where
     liftShowsPrec2 spk slk spv slv d m =
         showsUnaryWith (liftShowsPrec sp sl) "fromList" d (toList m)
@@ -353,7 +333,6 @@ instance (Eq k, Hashable k, Read k) => Read1 (HashMap k) where
       where
         rp' = liftReadsPrec rp rl
         rl' = liftReadList rp rl
-#endif
 
 instance (Eq k, Hashable k, Read k, Read e) => Read (HashMap k e) where
     readPrec = parens $ prec 10 $ do
@@ -371,13 +350,11 @@ instance Traversable (HashMap k) where
     traverse f = traverseWithKey (const f)
     {-# INLINABLE traverse #-}
 
-#if MIN_VERSION_base(4,9,0)
 instance Eq2 HashMap where
     liftEq2 = equal2
 
 instance Eq k => Eq1 (HashMap k) where
     liftEq = equal1
-#endif
 
 -- | Note that, in the presence of hash collisions, equal @HashMap@s may
 -- behave differently, i.e. substitutivity may be violated:
@@ -441,13 +418,11 @@ equal2 eqk eqv t1 t2 = go (toList' t1 []) (toList' t2 [])
 
     leafEq (L k v) (L k' v') = eqk k k' && eqv v v'
 
-#if MIN_VERSION_base(4,9,0)
 instance Ord2 HashMap where
     liftCompare2 = cmp
 
 instance Ord k => Ord1 (HashMap k) where
     liftCompare = cmp compare
-#endif
 
 -- | The ordering is total and consistent with the `Eq` instance. However,
 -- nothing else about the ordering is specified, and it may change from
@@ -775,11 +750,7 @@ lookupDefault def k t = findWithDefault def k t
 
 -- | /O(log n)/ Return the value to which the specified key is mapped.
 -- Calls 'error' if this map contains no mapping for the key.
-#if MIN_VERSION_base(4,9,0)
 (!) :: (Eq k, Hashable k, HasCallStack) => HashMap k v -> k -> v
-#else
-(!) :: (Eq k, Hashable k) => HashMap k v -> k -> v
-#endif
 (!) m k = case lookup k m of
     Just v  -> v
     Nothing -> error "Data.HashMap.Internal.(!): key not found"
@@ -1331,7 +1302,6 @@ alterF f = \ !k !m ->
 -- rule from firing.
 {-# INLINABLE [0] alterF #-}
 
-#if MIN_VERSION_base(4,8,0)
 -- This is just a bottom value. See the comment on the "alterFWeird"
 -- rule.
 test_bottom :: a
@@ -1448,7 +1418,6 @@ alterFEager f !k m = (<$> f mv) $ \fres ->
            Absent -> Nothing
            Present v _ -> Just v
 {-# INLINABLE alterFEager #-}
-#endif
 
 -- | /O(n*log m)/ Inclusion of maps. A map is included in another map if the keys
 -- are subsets and the corresponding values are equal:

Data/HashMap/Internal/Array.hs

@@ -71,35 +71,19 @@ module Data.HashMap.Internal.Array
     , fromList
     ) where
 
-#if !MIN_VERSION_base(4,8,0)
-import Control.Applicative (Applicative (..), (<$>))
-#endif
 import Control.Applicative (liftA2)
 import Control.DeepSeq (NFData (..))
 import GHC.Exts(Int(..), Int#, reallyUnsafePtrEquality#, tagToEnum#, unsafeCoerce#, State#)
 import GHC.ST (ST(..))
-import Control.Monad.ST (stToIO)
+import Control.Monad.ST (runST, stToIO)
 
-#if __GLASGOW_HASKELL__ >= 709
 import Prelude hiding (filter, foldMap, foldr, foldl, length, map, read, traverse, all)
-#else
-import Prelude hiding (filter, foldr, foldl, length, map, read, all)
-#endif
 
-#if __GLASGOW_HASKELL__ >= 710
 import GHC.Exts (SmallArray#, newSmallArray#, readSmallArray#, writeSmallArray#,
                  indexSmallArray#, unsafeFreezeSmallArray#, unsafeThawSmallArray#,
                  SmallMutableArray#, sizeofSmallArray#, copySmallArray#, thawSmallArray#,
                  sizeofSmallMutableArray#, copySmallMutableArray#, cloneSmallMutableArray#)
 
-#else
-import GHC.Exts (Array#, newArray#, readArray#, writeArray#,
-                 indexArray#, unsafeFreezeArray#, unsafeThawArray#,
-                 MutableArray#, sizeofArray#, copyArray#, thawArray#,
-                 sizeofMutableArray#, copyMutableArray#, cloneMutableArray#)
-import Data.Monoid (Monoid (..))
-#endif
-
 #if defined(ASSERTS)
 import qualified Prelude
 #endif
@@ -108,11 +92,9 @@ import qualified Prelude
 import qualified Control.DeepSeq as NF
 #endif
 
-import Data.HashMap.Internal.Unsafe (runST)
 import Control.Monad ((>=>))
 
 
-#if __GLASGOW_HASKELL__ >= 710
 type Array# a = SmallArray# a
 type MutableArray# a = SmallMutableArray# a
 
@@ -175,7 +157,6 @@ copyMutableArray# :: SmallMutableArray# d a
                   -> State# d
                   -> State# d
 copyMutableArray# = copySmallMutableArray#
-#endif
 
 ------------------------------------------------------------------------