diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,10 @@
 # Revision history for recover-rtti
 
+## 0.5.1 -- 2025-07-19
+
+* Relax bounds, including support for `QuickCheck-2.16`
+* Drop support for `ghc < 9.2`
+
 ## 0.5.0 -- 2024-06-12
 
 * Support ghc 9.8 and 9.10, including bytestring 0.12
diff --git a/recover-rtti.cabal b/recover-rtti.cabal
--- a/recover-rtti.cabal
+++ b/recover-rtti.cabal
@@ -1,6 +1,6 @@
 cabal-version:      2.4
 name:               recover-rtti
-version:            0.5.0
+version:            0.5.1
 synopsis:           Recover run-time type information from the GHC heap
 description:        The main function in this package is 'classify', which looks
                     at the GHC heap to recover type information about arbitrary
@@ -16,110 +16,131 @@
 maintainer:         edsko@well-typed.com
 copyright:          Juspay Technologies Pvt Ltd, Well-Typed LLP
 category:           Debugging
-extra-source-files:
-    README.md
-    CHANGELOG.md
-
-Tested-With: GHC ==8.10.7
-              || ==9.0.2
-              || ==9.2.7
-              || ==9.4.5
-              || ==9.6.2
-              || ==9.8.2
-              || ==9.10.1
+extra-doc-files:    README.md
+                    CHANGELOG.md
+tested-with:        GHC==9.2.8
+                    GHC==9.4.8
+                    GHC==9.6.7
+                    GHC==9.8.4
+                    GHC==9.10.2
+                    GHC==9.12.2
 
 source-repository head
   type:     git
   location: https://github.com/well-typed/recover-rtti
 
-library
-    exposed-modules:  Debug.RecoverRTTI
-                      Debug.RecoverRTTI.Classify
-                      Debug.RecoverRTTI.ClosureTree
+common lang
+  build-depends:    base >= 4.16 && < 4.22
+  default-language: GHC2021
 
-    other-modules:    Debug.RecoverRTTI.CheckSame
-                      Debug.RecoverRTTI.Classifier
-                      Debug.RecoverRTTI.Constraint
-                      Debug.RecoverRTTI.Debugging
-                      Debug.RecoverRTTI.FlatClosure
-                      Debug.RecoverRTTI.Modules
-                      Debug.RecoverRTTI.Nat
-                      Debug.RecoverRTTI.Reclassify
-                      Debug.RecoverRTTI.Tuple
-                      Debug.RecoverRTTI.Tuple.Recursive
-                      Debug.RecoverRTTI.Tuple.Size
-                      Debug.RecoverRTTI.Util
-                      Debug.RecoverRTTI.Wrappers
+  ghc-options:
+      -Wall
+      -Wprepositive-qualified-module
+      -Wredundant-constraints
+      -Wunused-packages
 
-    build-depends:    base       >= 4.13 && < 4.21
-                    , aeson      >= 1.4  && < 2.3
-                    , bytestring >= 0.10 && < 0.13
-                    , containers >= 0.6  && < 0.8
-                    , ghc-heap   >= 8.8  && < 9.11
-                    , ghc-prim   >= 0.5  && < 0.12
-                    , sop-core   >= 0.5  && < 0.6
-                    , stm        >= 2.5  && < 2.6
-                    , text       >= 1.2  && < 2.2
+  default-extensions:
+      DataKinds
+      DerivingVia
+      DerivingStrategies
+      LambdaCase
+      PatternSynonyms
+      QuantifiedConstraints
+      RecordWildCards
+      TypeFamilies
+      UndecidableInstances
+      UndecidableSuperClasses
+      ViewPatterns
 
-                      -- mtl 2.3 does not have ExceptT?
-                    , mtl (>= 2.2 && < 2.3) || (>= 2.3.1 && < 2.4)
+library
+  import:         lang
+  hs-source-dirs: src
 
-                      -- 0.2.12 introduces Data.HashMap.Internal.Array
-                    , unordered-containers >= 0.2.12 && < 0.3
+  exposed-modules:
+      Debug.RecoverRTTI
+      Debug.RecoverRTTI.Classify
+      Debug.RecoverRTTI.ClosureTree
 
-                      -- The oldest ghc we support is 8.8.
-                      -- The dependencies below are the oldest versions of
-                      -- these packages that compile with this ghc version.
-                    , vector    >= 0.12.1.2 && < 0.14
-                    , primitive >= 0.7      && < 0.10
+  other-modules:
+      Debug.RecoverRTTI.CheckSame
+      Debug.RecoverRTTI.Classifier
+      Debug.RecoverRTTI.Constraint
+      Debug.RecoverRTTI.Debugging
+      Debug.RecoverRTTI.FlatClosure
+      Debug.RecoverRTTI.Modules
+      Debug.RecoverRTTI.Nat
+      Debug.RecoverRTTI.Reclassify
+      Debug.RecoverRTTI.Tuple
+      Debug.RecoverRTTI.Tuple.Recursive
+      Debug.RecoverRTTI.Tuple.Size
+      Debug.RecoverRTTI.Util
+      Debug.RecoverRTTI.Wrappers
 
-    -- later versions of primitive use a compat package for Data.Array.Byte
-    if impl(ghc < 9.4)
-      build-depends: data-array-byte >= 0.1 && < 0.2
+  build-depends:
+      -- bundled libraries
+    , bytestring >= 0.11 && < 0.13
+    , containers >= 0.6  && < 0.8
+    , ghc-heap   >= 9.2  && < 9.13
+    , mtl        >= 2.2  && < 2.4
+    , stm        >= 2.5  && < 2.6
+    , text       >= 1.2  && < 2.2
 
-    if impl(ghc >= 9.10)
-      build-depends: ghc-internal
+  build-depends:
+    , aeson      >= 1.4  && < 2.3
+    , sop-core   >= 0.5  && < 0.6
+    , vector     >= 0.12 && < 0.14
+    , primitive  >= 0.7  && < 0.10
 
-    hs-source-dirs:   src
-    default-language: Haskell2010
-    ghc-options:      -Wall
-                      -Wredundant-constraints
+      -- 0.2.12 introduces Data.HashMap.Internal.Array
+    , unordered-containers >= 0.2.12 && < 0.3
 
+  other-extensions:
+      CPP
+
 test-suite test-recover-rtti
-    default-language: Haskell2010
-    type:             exitcode-stdio-1.0
-    hs-source-dirs:   tests
-    main-is:          RecoverRttiTests.hs
-    other-modules:    Test.RecoverRTTI.Classifier.Arbitrary
-                      Test.RecoverRTTI.Classifier.Equality
-                      Test.RecoverRTTI.Classifier.Size
-                      Test.RecoverRTTI.Classify
-                      Test.RecoverRTTI.ConcreteClassifier
-                      Test.RecoverRTTI.Globals
-                      Test.RecoverRTTI.Prim
-                      Test.RecoverRTTI.QuickCheck.DepGen
-                      Test.RecoverRTTI.QuickCheck.Sized
-                      Test.RecoverRTTI.Sanity
-                      Test.RecoverRTTI.Show
-                      Test.RecoverRTTI.Staged
-                      Test.RecoverRTTI.UserDefined
-    build-depends:    base >= 4.13
-                    , recover-rtti
+  import: lang
+  type:             exitcode-stdio-1.0
+  hs-source-dirs:   tests
+  main-is:          RecoverRttiTests.hs
+  build-depends:    recover-rtti
 
-                    , aeson
-                    , bytestring
-                    , containers
-                    , ghc-heap
-                    , ghc-prim
-                    , mtl
-                    , primitive
-                    , QuickCheck
-                    , sop-core
-                    , stm
-                    , tasty
-                    , tasty-hunit
-                    , tasty-quickcheck
-                    , text
-                    , unordered-containers
-                    , vector
-    ghc-options:      -Wall
+  other-modules:
+      Test.RecoverRTTI.Classifier.Arbitrary
+      Test.RecoverRTTI.Classifier.Equality
+      Test.RecoverRTTI.Classifier.Size
+      Test.RecoverRTTI.Classify
+      Test.RecoverRTTI.ConcreteClassifier
+      Test.RecoverRTTI.Globals
+      Test.RecoverRTTI.Prim
+      Test.RecoverRTTI.QuickCheck.DepGen
+      Test.RecoverRTTI.QuickCheck.Sized
+      Test.RecoverRTTI.Sanity
+      Test.RecoverRTTI.Show
+      Test.RecoverRTTI.Staged
+      Test.RecoverRTTI.UserDefined
+
+  build-depends:
+      -- inherited dependencies
+    , aeson
+    , bytestring
+    , containers
+    , mtl
+    , primitive
+    , sop-core
+    , stm
+    , text
+    , unordered-containers
+    , vector
+
+  build-depends:
+      -- new dependencies
+    , QuickCheck       >= 2.15 && < 2.17
+    , tasty            >= 1.5  && < 1.6
+    , tasty-hunit      >= 0.10 && < 0.11
+    , tasty-quickcheck >= 0.11 && < 0.12
+
+  other-extensions:
+      CPP
+      MagicHash
+      UnboxedTuples
+      OverloadedStrings
diff --git a/src/Debug/RecoverRTTI.hs b/src/Debug/RecoverRTTI.hs
--- a/src/Debug/RecoverRTTI.hs
+++ b/src/Debug/RecoverRTTI.hs
@@ -1,6 +1,6 @@
 -- | Recover runtime type information
 module Debug.RecoverRTTI (
-    -- * Take advance of the recovered type information
+    -- * Take advantage of the recovered type information
     anythingToString
     -- * Debugging support
     -- ** Tracing
diff --git a/src/Debug/RecoverRTTI/CheckSame.hs b/src/Debug/RecoverRTTI/CheckSame.hs
--- a/src/Debug/RecoverRTTI/CheckSame.hs
+++ b/src/Debug/RecoverRTTI/CheckSame.hs
@@ -1,11 +1,4 @@
-{-# LANGUAGE CPP                 #-}
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeOperators       #-}
+{-# LANGUAGE CPP #-}
 
 module Debug.RecoverRTTI.CheckSame (
     -- * Check if two classifiers are the same
diff --git a/src/Debug/RecoverRTTI/Classifier.hs b/src/Debug/RecoverRTTI/Classifier.hs
--- a/src/Debug/RecoverRTTI/Classifier.hs
+++ b/src/Debug/RecoverRTTI/Classifier.hs
@@ -1,14 +1,4 @@
-{-# LANGUAGE CPP                   #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE KindSignatures        #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE QuantifiedConstraints #-}
-{-# LANGUAGE RankNTypes            #-}
-{-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE StandaloneDeriving    #-}
-{-# LANGUAGE UndecidableInstances  #-}
+{-# LANGUAGE CPP #-}
 
 module Debug.RecoverRTTI.Classifier (
     Classifier
@@ -24,6 +14,9 @@
   ) where
 
 import Data.Aeson (Value)
+import Data.ByteString qualified as BS.Strict
+import Data.ByteString.Lazy qualified as BS.Lazy
+import Data.HashMap.Internal.Array qualified as HashMap (Array)
 import Data.HashMap.Lazy (HashMap)
 import Data.HashSet (HashSet)
 import Data.Int
@@ -31,26 +24,22 @@
 import Data.IntSet (IntSet)
 import Data.Kind
 import Data.Map (Map)
+import Data.Primitive.Array qualified as Prim (Array)
+import Data.Primitive.ByteArray qualified as Prim (ByteArray)
 import Data.Ratio
 import Data.Sequence (Seq)
 import Data.Set (Set)
 import Data.SOP
 import Data.SOP.Dict
+import Data.Text qualified as Text.Strict
+import Data.Text.Lazy qualified as Text.Lazy
 import Data.Tree (Tree)
+import Data.Vector qualified as Vector.Boxed
 import Data.Void
 import Data.Word
 
-import qualified Data.ByteString             as BS.Strict
-import qualified Data.ByteString.Lazy        as BS.Lazy
-import qualified Data.HashMap.Internal.Array as HashMap (Array)
-import qualified Data.Primitive.Array        as Prim (Array)
-import qualified Data.Primitive.ByteArray    as Prim (ByteArray)
-import qualified Data.Text                   as Text.Strict
-import qualified Data.Text.Lazy              as Text.Lazy
-import qualified Data.Vector                 as Vector.Boxed
-
 #if !MIN_VERSION_bytestring(0,12,0)
-import qualified Data.ByteString.Short as BS.Short
+import Data.ByteString.Short qualified as BS.Short
 #endif
 
 import Debug.RecoverRTTI.Nat
diff --git a/src/Debug/RecoverRTTI/Classify.hs b/src/Debug/RecoverRTTI/Classify.hs
--- a/src/Debug/RecoverRTTI/Classify.hs
+++ b/src/Debug/RecoverRTTI/Classify.hs
@@ -1,19 +1,4 @@
-{-# LANGUAGE CPP                   #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE FlexibleInstances     #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE PatternSynonyms       #-}
-{-# LANGUAGE QuantifiedConstraints #-}
-{-# LANGUAGE RankNTypes            #-}
-{-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE StandaloneDeriving    #-}
-{-# LANGUAGE TupleSections         #-}
-{-# LANGUAGE TypeApplications      #-}
-{-# LANGUAGE TypeOperators         #-}
-{-# LANGUAGE UndecidableInstances  #-}
-{-# LANGUAGE ViewPatterns          #-}
+{-# LANGUAGE CPP #-}
 
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
@@ -38,35 +23,31 @@
   ) where
 
 import Control.Monad
-import Control.Monad.Except
+import Control.Monad.Except (ExceptT(..), runExceptT)
+import Control.Monad.Trans (lift)
+import Data.Foldable qualified as Foldable
+import Data.HashMap.Internal.Array qualified as HashMap (Array)
+import Data.HashMap.Internal.Array qualified as HashMap.Array
 import Data.HashMap.Lazy (HashMap)
+import Data.HashMap.Lazy qualified as HashMap
 import Data.IntMap (IntMap)
 import Data.Map (Map)
+import Data.Map qualified as Map
+import Data.Primitive.Array qualified as Prim (Array)
+import Data.Primitive.Array qualified as Prim.Array
 import Data.Sequence (Seq)
 import Data.Set (Set)
 import Data.SOP
 import Data.SOP.Dict
 import Data.Tree (Tree)
+import Data.Tree qualified as Tree
+import Data.Vector qualified as Vector.Boxed
 import Data.Void
 import GHC.Exts.Heap (Closure)
 import GHC.Real
 import System.IO.Unsafe (unsafePerformIO)
 import Unsafe.Coerce (unsafeCoerce)
 
-#if MIN_VERSION_mtl(2,3,0)
-import Control.Monad.Trans
-#endif
-
-import qualified Data.Foldable               as Foldable
-import qualified Data.HashMap.Internal.Array as HashMap (Array)
-import qualified Data.HashMap.Internal.Array as HashMap.Array
-import qualified Data.HashMap.Lazy           as HashMap
-import qualified Data.Map                    as Map
-import qualified Data.Primitive.Array        as Prim.Array
-import qualified Data.Primitive.Array        as Prim (Array)
-import qualified Data.Tree                   as Tree
-import qualified Data.Vector                 as Vector.Boxed
-
 import Debug.RecoverRTTI.Classifier
 import Debug.RecoverRTTI.Constraint
 import Debug.RecoverRTTI.FlatClosure
@@ -128,11 +109,7 @@
       --
 
       -- bytestring
-#if MIN_VERSION_bytestring(0,11,0)
       (inKnownModule DataByteStringInternal      -> Just "BS")    -> return $ mustBe $ C_Prim C_BS_Strict
-#else
-      (inKnownModule DataByteStringInternal      -> Just "PS")    -> return $ mustBe $ C_Prim C_BS_Strict
-#endif
       (inKnownModule DataByteStringLazyInternal  -> Just "Empty") -> return $ mustBe $ C_Prim C_BS_Lazy
       (inKnownModule DataByteStringLazyInternal  -> Just "Chunk") -> return $ mustBe $ C_Prim C_BS_Lazy
 #if !MIN_VERSION_bytestring(0,12,0)
diff --git a/src/Debug/RecoverRTTI/Constraint.hs b/src/Debug/RecoverRTTI/Constraint.hs
--- a/src/Debug/RecoverRTTI/Constraint.hs
+++ b/src/Debug/RecoverRTTI/Constraint.hs
@@ -1,15 +1,4 @@
-{-# LANGUAGE ConstraintKinds         #-}
-{-# LANGUAGE CPP                     #-}
-{-# LANGUAGE DataKinds               #-}
-{-# LANGUAGE FlexibleContexts        #-}
-{-# LANGUAGE FlexibleInstances       #-}
-{-# LANGUAGE GADTs                   #-}
-{-# LANGUAGE KindSignatures          #-}
-{-# LANGUAGE QuantifiedConstraints   #-}
-{-# LANGUAGE RankNTypes              #-}
-{-# LANGUAGE ScopedTypeVariables     #-}
-{-# LANGUAGE UndecidableInstances    #-}
-{-# LANGUAGE UndecidableSuperClasses #-}
+{-# LANGUAGE CPP #-}
 
 -- | Establish that a constraint holds for all classified types
 module Debug.RecoverRTTI.Constraint (
@@ -20,6 +9,9 @@
   ) where
 
 import Data.Aeson (Value)
+import Data.ByteString qualified as BS.Strict
+import Data.ByteString.Lazy qualified as BS.Lazy
+import Data.HashMap.Internal.Array qualified as HashMap (Array)
 import Data.HashMap.Lazy (HashMap)
 import Data.HashSet (HashSet)
 import Data.Int
@@ -27,26 +19,22 @@
 import Data.IntSet (IntSet)
 import Data.Kind
 import Data.Map (Map)
+import Data.Primitive.Array qualified as Prim (Array)
+import Data.Primitive.ByteArray qualified as Prim (ByteArray)
 import Data.Ratio
 import Data.Sequence (Seq)
 import Data.Set (Set)
 import Data.SOP
 import Data.SOP.Dict
+import Data.Text qualified as Text.Strict
+import Data.Text.Lazy qualified as Text.Lazy
 import Data.Tree (Tree)
+import Data.Vector qualified as Vector.Boxed
 import Data.Void
 import Data.Word
 
-import qualified Data.ByteString             as BS.Strict
-import qualified Data.ByteString.Lazy        as BS.Lazy
-import qualified Data.HashMap.Internal.Array as HashMap (Array)
-import qualified Data.Primitive.Array        as Prim (Array)
-import qualified Data.Primitive.ByteArray    as Prim (ByteArray)
-import qualified Data.Text                   as Text.Strict
-import qualified Data.Text.Lazy              as Text.Lazy
-import qualified Data.Vector                 as Vector.Boxed
-
 #if !MIN_VERSION_bytestring(0,12,0)
-import qualified Data.ByteString.Short as BS.Short
+import Data.ByteString.Short qualified as BS.Short
 #endif
 
 import Debug.RecoverRTTI.Classifier
diff --git a/src/Debug/RecoverRTTI/Debugging.hs b/src/Debug/RecoverRTTI/Debugging.hs
--- a/src/Debug/RecoverRTTI/Debugging.hs
+++ b/src/Debug/RecoverRTTI/Debugging.hs
@@ -1,5 +1,3 @@
-{-# LANGUAGE ExistentialQuantification #-}
-
 -- | Debugging support
 module Debug.RecoverRTTI.Debugging (
     -- * Tracing
diff --git a/src/Debug/RecoverRTTI/FlatClosure.hs b/src/Debug/RecoverRTTI/FlatClosure.hs
--- a/src/Debug/RecoverRTTI/FlatClosure.hs
+++ b/src/Debug/RecoverRTTI/FlatClosure.hs
@@ -1,8 +1,3 @@
-{-# LANGUAGE BangPatterns    #-}
-{-# LANGUAGE LambdaCase      #-}
-{-# LANGUAGE NamedFieldPuns  #-}
-{-# LANGUAGE RecordWildCards #-}
-
 module Debug.RecoverRTTI.FlatClosure (
     FlatClosure(..)
   , getBoxedClosureData
@@ -14,7 +9,7 @@
 import Control.Exception (evaluate)
 import Control.Monad
 import GHC.Exts.Heap (Box(..), asBox)
-import qualified GHC.Exts.Heap as H
+import GHC.Exts.Heap qualified as H
 
 -- | Flattened form of 'Closure' (with indirection nodes removed)
 --
diff --git a/src/Debug/RecoverRTTI/Modules.hs b/src/Debug/RecoverRTTI/Modules.hs
--- a/src/Debug/RecoverRTTI/Modules.hs
+++ b/src/Debug/RecoverRTTI/Modules.hs
@@ -1,10 +1,5 @@
-{-# LANGUAGE CPP            #-}
-{-# LANGUAGE DataKinds      #-}
-{-# LANGUAGE GADTs          #-}
-{-# LANGUAGE KindSignatures #-}
-{-# LANGUAGE LambdaCase     #-}
-{-# LANGUAGE NamedFieldPuns #-}
-{-# LANGUAGE TypeFamilies   #-}
+{-# LANGUAGE CPP       #-}
+{-# LANGUAGE MagicHash #-}
 
 -- | Modules we recognize types from
 module Debug.RecoverRTTI.Modules (
@@ -272,9 +267,26 @@
         SGhcPrim -> \case
           GhcTypes -> "GHC.Types"
 
+    -- ghc-prim versions bundled with ghc:
+    --
+    -- >         base   ghc-prim
+    -- > -----------------------
+    -- > 9.2.8   4.16   0.8
+    -- > 9.4.8   4.17   0.9.1
+    -- > 9.6.7   4.18   0.10.0
+    -- > 9.8.4   4.19   0.11.0
+    -- > 9.10.2  4.20   0.12.0
+    -- > 9.12.2  4.21   0.13.0
+    --
+    -- If we want to use @MIN_VERSION_ghc_prim@, we need to declare a dependency
+    -- on @ghc-prim@; since, we don't /actually/ depend on it, however, other
+    -- than to check the version, this results in unused package warnings.
+    -- We therefore use the version of base as a proxy.
+
 #if MIN_VERSION_base(4,20,0)
           GhcTuple -> "GHC.Tuple"
-#elif MIN_VERSION_ghc_prim(0,10,0)
+#elif MIN_VERSION_base(4,18,0)
+          -- from ghc-prim-0.10
           GhcTuple -> "GHC.Tuple.Prim"
 #else
           GhcTuple -> "GHC.Tuple"
@@ -311,11 +323,7 @@
 #endif
 
         SByteString -> \case
-#if MIN_VERSION_bytestring(0,11,4)
           DataByteStringInternal      -> "Data.ByteString.Internal.Type"
-#else
-          DataByteStringInternal      -> "Data.ByteString.Internal"
-#endif
           DataByteStringLazyInternal  -> "Data.ByteString.Lazy.Internal"
           DataByteStringShortInternal -> "Data.ByteString.Short.Internal"
 
diff --git a/src/Debug/RecoverRTTI/Nat.hs b/src/Debug/RecoverRTTI/Nat.hs
--- a/src/Debug/RecoverRTTI/Nat.hs
+++ b/src/Debug/RecoverRTTI/Nat.hs
@@ -1,10 +1,3 @@
-{-# LANGUAGE DataKinds            #-}
-{-# LANGUAGE GADTs                #-}
-{-# LANGUAGE PolyKinds            #-}
-{-# LANGUAGE ScopedTypeVariables  #-}
-{-# LANGUAGE TypeFamilies         #-}
-{-# LANGUAGE TypeOperators        #-}
-
 -- | Inductive type-level natural numbers
 module Debug.RecoverRTTI.Nat (
     -- * Type-level natural numbers
diff --git a/src/Debug/RecoverRTTI/Reclassify.hs b/src/Debug/RecoverRTTI/Reclassify.hs
--- a/src/Debug/RecoverRTTI/Reclassify.hs
+++ b/src/Debug/RecoverRTTI/Reclassify.hs
@@ -1,12 +1,3 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE KindSignatures      #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeOperators       #-}
-
 -- | Support for reclassification
 module Debug.RecoverRTTI.Reclassify (
     Reclassified(..)
diff --git a/src/Debug/RecoverRTTI/Tuple.hs b/src/Debug/RecoverRTTI/Tuple.hs
--- a/src/Debug/RecoverRTTI/Tuple.hs
+++ b/src/Debug/RecoverRTTI/Tuple.hs
@@ -1,13 +1,3 @@
-{-# LANGUAGE DataKinds            #-}
-{-# LANGUAGE FlexibleContexts     #-}
-{-# LANGUAGE GADTs                #-}
-{-# LANGUAGE PatternSynonyms      #-}
-{-# LANGUAGE ScopedTypeVariables  #-}
-{-# LANGUAGE TypeApplications     #-}
-{-# LANGUAGE TypeOperators        #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE ViewPatterns         #-}
-
 module Debug.RecoverRTTI.Tuple (
     -- * Wrapped tuple
     WrappedTuple(WrappedTuple, TNil, TCons)
diff --git a/src/Debug/RecoverRTTI/Tuple/Recursive.hs b/src/Debug/RecoverRTTI/Tuple/Recursive.hs
--- a/src/Debug/RecoverRTTI/Tuple/Recursive.hs
+++ b/src/Debug/RecoverRTTI/Tuple/Recursive.hs
@@ -1,11 +1,5 @@
 {-# OPTIONS_GHC -Wno-overlapping-patterns -Wno-incomplete-patterns -Wno-incomplete-uni-patterns -fno-opt-coercion #-}
 
-{-# LANGUAGE DataKinds               #-}
-{-# LANGUAGE FlexibleContexts        #-}
-{-# LANGUAGE ScopedTypeVariables     #-}
-{-# LANGUAGE TypeFamilies            #-}
-{-# LANGUAGE TypeOperators           #-}
-
 -- | Provide a recursive views on tuples
 --
 -- NOTE: We disable the GHC pattern match checker (this makes compilation /much/
diff --git a/src/Debug/RecoverRTTI/Tuple/Size.hs b/src/Debug/RecoverRTTI/Tuple/Size.hs
--- a/src/Debug/RecoverRTTI/Tuple/Size.hs
+++ b/src/Debug/RecoverRTTI/Tuple/Size.hs
@@ -1,14 +1,3 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE EmptyCase           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE FlexibleInstances   #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE KindSignatures      #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
-
 {-# OPTIONS_GHC -Wno-overlapping-patterns -Wno-incomplete-patterns -Wno-incomplete-uni-patterns -fno-opt-coercion #-}
 
 -- | Valid tuple size
diff --git a/src/Debug/RecoverRTTI/Util.hs b/src/Debug/RecoverRTTI/Util.hs
--- a/src/Debug/RecoverRTTI/Util.hs
+++ b/src/Debug/RecoverRTTI/Util.hs
@@ -1,13 +1,3 @@
-{-# LANGUAGE ConstraintKinds     #-}
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE PolyKinds           #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeOperators       #-}
-
 module Debug.RecoverRTTI.Util (
     -- * Existentials
     Some(..)
diff --git a/src/Debug/RecoverRTTI/Wrappers.hs b/src/Debug/RecoverRTTI/Wrappers.hs
--- a/src/Debug/RecoverRTTI/Wrappers.hs
+++ b/src/Debug/RecoverRTTI/Wrappers.hs
@@ -31,11 +31,10 @@
 
 import Control.Concurrent.MVar (MVar)
 import Control.Concurrent.STM (TVar)
+import Data.Primitive.Array qualified as Prim (MutableArray)
+import Data.Primitive.ByteArray qualified as Prim (MutableByteArray)
 import Data.STRef (STRef)
 import GHC.Exts
-
-import qualified Data.Primitive.Array     as Prim (MutableArray)
-import qualified Data.Primitive.ByteArray as Prim (MutableByteArray)
 
 {-------------------------------------------------------------------------------
   User-defined types
diff --git a/tests/RecoverRttiTests.hs b/tests/RecoverRttiTests.hs
--- a/tests/RecoverRttiTests.hs
+++ b/tests/RecoverRttiTests.hs
@@ -2,9 +2,9 @@
 
 import Test.Tasty
 
-import qualified Test.RecoverRTTI.Sanity
-import qualified Test.RecoverRTTI.Classify
-import qualified Test.RecoverRTTI.Show
+import Test.RecoverRTTI.Sanity   qualified
+import Test.RecoverRTTI.Classify qualified
+import Test.RecoverRTTI.Show     qualified
 
 main :: IO ()
 main = defaultMain tests
diff --git a/tests/Test/RecoverRTTI/Classifier/Arbitrary.hs b/tests/Test/RecoverRTTI/Classifier/Arbitrary.hs
--- a/tests/Test/RecoverRTTI/Classifier/Arbitrary.hs
+++ b/tests/Test/RecoverRTTI/Classifier/Arbitrary.hs
@@ -1,50 +1,39 @@
-{-# LANGUAGE CPP                   #-}
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE KindSignatures        #-}
-{-# LANGUAGE LambdaCase            #-}
-{-# LANGUAGE QuantifiedConstraints #-}
-{-# LANGUAGE RankNTypes            #-}
-{-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE TypeOperators         #-}
+{-# LANGUAGE CPP #-}
 
 module Test.RecoverRTTI.Classifier.Arbitrary (arbitraryClassifier_) where
 
 import Data.Bifunctor
+import Data.HashMap.Internal.Array qualified as HashMap.Array
+import Data.HashMap.Lazy qualified as HashMap
+import Data.HashSet qualified as HashSet
+import Data.IntMap qualified as IntMap
 import Data.Kind
+import Data.Map qualified as Map
+import Data.Sequence qualified as Seq
+import Data.Set qualified as Set
 import Data.SOP
 import Data.Tree (Tree)
+import Data.Tree qualified as Tree
+import Data.Vector qualified as Vector.Boxed
 import Data.Void
 import GHC.Real (Ratio((:%)))
 
 #if MIN_VERSION_base(4,17,0)
-import qualified GHC.IsList as IsList
+import GHC.IsList qualified as IsList
 #else
-import qualified GHC.Exts as IsList (fromList)
+import GHC.Exts qualified as IsList (fromList)
 #endif
 
-import qualified Data.HashMap.Internal.Array as HashMap.Array
-import qualified Data.HashMap.Lazy           as HashMap
-import qualified Data.HashSet                as HashSet
-import qualified Data.IntMap                 as IntMap
-import qualified Data.Map                    as Map
-import qualified Data.Sequence               as Seq
-import qualified Data.Set                    as Set
-import qualified Data.Tree                   as Tree
-import qualified Data.Vector                 as Vector.Boxed
-
 import Debug.RecoverRTTI
 import Debug.RecoverRTTI.Classify
 
-import Test.QuickCheck
+import Test.QuickCheck (Gen)
 
 import Test.RecoverRTTI.Classifier.Equality ()
 import Test.RecoverRTTI.Prim
 import Test.RecoverRTTI.QuickCheck.DepGen
 import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)
-
-import qualified Test.RecoverRTTI.QuickCheck.Sized as SG
+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG
 
 {-------------------------------------------------------------------------------
   Generate arbitiary classifiers
diff --git a/tests/Test/RecoverRTTI/Classifier/Equality.hs b/tests/Test/RecoverRTTI/Classifier/Equality.hs
--- a/tests/Test/RecoverRTTI/Classifier/Equality.hs
+++ b/tests/Test/RecoverRTTI/Classifier/Equality.hs
@@ -4,9 +4,8 @@
 module Test.RecoverRTTI.Classifier.Equality () where
 
 import Data.Function (on)
-
-import qualified Data.HashMap.Internal.Array as HashMap (Array)
-import qualified Data.HashMap.Internal.Array as HashMap.Array
+import Data.HashMap.Internal.Array qualified as HashMap (Array)
+import Data.HashMap.Internal.Array qualified as HashMap.Array
 
 import Debug.RecoverRTTI
 
diff --git a/tests/Test/RecoverRTTI/Classifier/Size.hs b/tests/Test/RecoverRTTI/Classifier/Size.hs
--- a/tests/Test/RecoverRTTI/Classifier/Size.hs
+++ b/tests/Test/RecoverRTTI/Classifier/Size.hs
@@ -1,8 +1,3 @@
-{-# LANGUAGE FlexibleContexts    #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-
 module Test.RecoverRTTI.Classifier.Size (classifierSize_) where
 
 import Data.SOP
diff --git a/tests/Test/RecoverRTTI/Classify.hs b/tests/Test/RecoverRTTI/Classify.hs
--- a/tests/Test/RecoverRTTI/Classify.hs
+++ b/tests/Test/RecoverRTTI/Classify.hs
@@ -1,41 +1,38 @@
-{-# LANGUAGE CPP                 #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE LambdaCase          #-}
-{-# LANGUAGE OverloadedStrings   #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
+{-# LANGUAGE CPP               #-}
+{-# LANGUAGE OverloadedStrings #-}
 
 -- | Verify we infer the right classifier
 module Test.RecoverRTTI.Classify (tests) where
 
 import Control.Monad.Except
+import Data.Aeson qualified as Aeson
+import Data.HashMap.Internal.Array qualified as HashMap.Array
+import Data.HashMap.Lazy qualified as HashMap
+import Data.HashSet qualified as HashSet
+import Data.IntMap qualified as IntMap
+import Data.IntSet qualified as IntSet
+import Data.Map qualified as Map
 import Data.Ratio
+import Data.Sequence qualified as Seq
+import Data.Set qualified as Set
 import Data.SOP
+import Data.Tree qualified as Tree
 import Data.Type.Equality
+import Data.Vector qualified as Vector.Boxed
+import Data.Vector.Primitive qualified as Vector.Primitive
+import Data.Vector.Storable qualified as Vector.Storable
 import Unsafe.Coerce (unsafeCoerce)
 
 #if MIN_VERSION_base(4,17,0)
-import qualified GHC.IsList as IsList
+import GHC.IsList qualified as IsList
 #else
-import qualified GHC.Exts as IsList (fromList)
+import GHC.Exts qualified as IsList (fromList)
 #endif
 
-import qualified Data.Aeson                  as Aeson
-import qualified Data.HashMap.Internal.Array as HashMap.Array
-import qualified Data.HashMap.Lazy           as HashMap
-import qualified Data.HashSet                as HashSet
-import qualified Data.IntMap                 as IntMap
-import qualified Data.IntSet                 as IntSet
-import qualified Data.Map                    as Map
-import qualified Data.Sequence               as Seq
-import qualified Data.Set                    as Set
-import qualified Data.Tree                   as Tree
-import qualified Data.Vector                 as Vector.Boxed
-import qualified Data.Vector.Storable        as Vector.Storable
-import qualified Data.Vector.Primitive       as Vector.Primitive
-
 import Test.Tasty
-import Test.Tasty.QuickCheck hiding (classify, NonEmpty)
+import Test.Tasty.QuickCheck (testProperty)
+import Test.QuickCheck (Property)
+import Test.QuickCheck qualified as QC
 
 import Debug.RecoverRTTI
 import Debug.RecoverRTTI.Classify
@@ -57,7 +54,7 @@
 -- but their on-heap representation may be different, and this may effect the
 -- RTTI recovery.
 prop_constants :: Property
-prop_constants = withMaxSuccess 1 $ conjoin [
+prop_constants = QC.withMaxSuccess 1 $ QC.conjoin [
       -- Primitive types
 
       compareClassifier $ Value (C_Prim C_Bool)     True
@@ -330,15 +327,15 @@
 -- The tests in this module differ only in how the produce the 'Value's.
 compareClassifier :: Value a -> Property
 compareClassifier = \(Value cc x) ->
-      counterexample ("Generated classifier: " ++ show cc)
+      QC.counterexample ("Generated classifier: " ++ show cc)
     $ case runExcept $ classifyConcrete x of
         Left err  ->
-            counterexample ("Failed to reclassify. Error: " ++ err)
-          $ property False
+            QC.counterexample ("Failed to reclassify. Error: " ++ err)
+          $ QC.property False
         Right (Reclassified cc' _pf) ->
           case sameConcrete cc cc' of
             Nothing ->
-                counterexample ("Inferred different classifier: " ++ show cc')
-              $ property False
+                QC.counterexample ("Inferred different classifier: " ++ show cc')
+              $ QC.property False
             Just Refl ->
-              property True
+              QC.property True
diff --git a/tests/Test/RecoverRTTI/ConcreteClassifier.hs b/tests/Test/RecoverRTTI/ConcreteClassifier.hs
--- a/tests/Test/RecoverRTTI/ConcreteClassifier.hs
+++ b/tests/Test/RecoverRTTI/ConcreteClassifier.hs
@@ -1,18 +1,3 @@
-{-# LANGUAGE ConstraintKinds         #-}
-{-# LANGUAGE DataKinds               #-}
-{-# LANGUAGE FlexibleContexts        #-}
-{-# LANGUAGE FlexibleInstances       #-}
-{-# LANGUAGE GADTs                   #-}
-{-# LANGUAGE KindSignatures          #-}
-{-# LANGUAGE LambdaCase              #-}
-{-# LANGUAGE QuantifiedConstraints   #-}
-{-# LANGUAGE RankNTypes              #-}
-{-# LANGUAGE ScopedTypeVariables     #-}
-{-# LANGUAGE StandaloneDeriving      #-}
-{-# LANGUAGE TypeOperators           #-}
-{-# LANGUAGE UndecidableInstances    #-}
-{-# LANGUAGE UndecidableSuperClasses #-}
-
 module Test.RecoverRTTI.ConcreteClassifier (
     -- * Concrete classifier
     ConcreteClassifier
@@ -43,17 +28,17 @@
 import Debug.RecoverRTTI
 import Debug.RecoverRTTI.Classify
 
-import Test.QuickCheck
+import Test.QuickCheck (Arbitrary(..), Gen)
+import Test.QuickCheck qualified as QC
 
 import Test.RecoverRTTI.Classifier.Arbitrary
 import Test.RecoverRTTI.Classifier.Equality ()
 import Test.RecoverRTTI.Classifier.Size
 import Test.RecoverRTTI.QuickCheck.DepGen
 import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)
+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG
 import Test.RecoverRTTI.UserDefined
 
-import qualified Test.RecoverRTTI.QuickCheck.Sized as SG
-
 {-------------------------------------------------------------------------------
   Concrete classifier
 
@@ -207,7 +192,7 @@
 arbitraryUser = SG.leafOrStep leaf compound
   where
     leaf :: Gen (Some (DepGen ClassifyUser))
-    leaf = oneof [
+    leaf = QC.oneof [
           -- SimpleType
           pure . Some $ arbitraryDepGen C_Simple
 
diff --git a/tests/Test/RecoverRTTI/Globals.hs b/tests/Test/RecoverRTTI/Globals.hs
--- a/tests/Test/RecoverRTTI/Globals.hs
+++ b/tests/Test/RecoverRTTI/Globals.hs
@@ -19,20 +19,19 @@
 import Control.Concurrent.STM (newTVarIO)
 import Control.Monad.ST.Unsafe (unsafeSTToIO)
 import Data.IORef (newIORef)
+import Data.Primitive.Array qualified as Prim.Array
+import Data.Primitive.ByteArray qualified as Prim.ByteArray
 import Data.STRef (newSTRef)
+import Data.Vector.Primitive qualified as Vector.Primitive
+import Data.Vector.Storable qualified as Vector.Storable
 import System.IO.Unsafe (unsafePerformIO)
 import Unsafe.Coerce (unsafeCoerce)
 
 #if MIN_VERSION_base(4,17,0)
-import qualified GHC.IsList as IsList
+import GHC.IsList qualified as IsList
 #else
-import qualified GHC.Exts as IsList (fromList)
+import GHC.Exts qualified as IsList (fromList)
 #endif
-
-import qualified Data.Primitive.Array     as Prim.Array
-import qualified Data.Primitive.ByteArray as Prim.ByteArray
-import qualified Data.Vector.Primitive    as Vector.Primitive
-import qualified Data.Vector.Storable     as Vector.Storable
 
 import Debug.RecoverRTTI
 
diff --git a/tests/Test/RecoverRTTI/Prim.hs b/tests/Test/RecoverRTTI/Prim.hs
--- a/tests/Test/RecoverRTTI/Prim.hs
+++ b/tests/Test/RecoverRTTI/Prim.hs
@@ -1,11 +1,4 @@
-{-# LANGUAGE CPP                        #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE FlexibleInstances          #-}
-{-# LANGUAGE GADTs                      #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE LambdaCase                 #-}
-{-# LANGUAGE OverloadedStrings          #-}
-{-# LANGUAGE StandaloneDeriving         #-}
+{-# LANGUAGE CPP #-}
 
 module Test.RecoverRTTI.Prim (
     -- * Equality
@@ -17,37 +10,37 @@
   ) where
 
 import Control.Monad (replicateM)
+import Data.Aeson qualified as Aeson
+import Data.ByteString qualified as BS.Strict
+import Data.ByteString.Lazy qualified as BS.Lazy
 import Data.Int
 import Data.IntSet (IntSet)
+import Data.Primitive.ByteArray qualified as Prim (ByteArray)
 import Data.SOP (Compose)
 import Data.SOP.Dict
 import Data.String (fromString)
+import Data.Text qualified as Text.Strict
+import Data.Text.Lazy qualified as Text.Lazy
+import Data.Vector qualified as Vector.Boxed
+import Data.Vector.Primitive qualified as Vector.Primitive
+import Data.Vector.Storable qualified as Vector.Storable
 import Data.Word
 import Unsafe.Coerce (unsafeCoerce)
 
 #if MIN_VERSION_base(4,17,0)
-import qualified GHC.IsList as IsList
+import GHC.IsList qualified as IsList
 #else
-import qualified GHC.Exts as IsList (fromList)
+import GHC.Exts qualified as IsList (fromList)
 #endif
 
-import qualified Data.Aeson               as Aeson
-import qualified Data.ByteString          as BS.Strict
-import qualified Data.ByteString.Lazy     as BS.Lazy
-import qualified Data.Primitive.ByteArray as Prim (ByteArray)
-import qualified Data.Text                as Text.Strict
-import qualified Data.Text.Lazy           as Text.Lazy
-import qualified Data.Vector              as Vector.Boxed
-import qualified Data.Vector.Primitive    as Vector.Primitive
-import qualified Data.Vector.Storable     as Vector.Storable
-
 #if !MIN_VERSION_bytestring(0,12,0)
-import qualified Data.ByteString.Short as BS.Short
+import Data.ByteString.Short qualified as BS.Short
 #endif
 
 import Debug.RecoverRTTI
 
-import Test.QuickCheck
+import Test.QuickCheck (Arbitrary(..), Gen)
+import Test.QuickCheck qualified as QC
 
 import Test.RecoverRTTI.Classifier.Equality ()
 import Test.RecoverRTTI.Globals
@@ -67,7 +60,7 @@
 primSatisfiesArbitrary = primSatisfies
 
 arbitraryPrimClassifier :: Gen (Some PrimClassifier)
-arbitraryPrimClassifier = elements [
+arbitraryPrimClassifier = QC.elements [
     -- Primitive types
 
       Some C_Bool
@@ -233,11 +226,11 @@
 -- but it generates values that are too big, which cause the size sanity check
 -- on the generator 'prop_showGenerated' to start to fail.
 instance Arbitrary (Wrap Aeson.Value) where
-  arbitrary = choose (0, 10) >>= fmap Wrap . go
+  arbitrary = QC.choose (0, 10) >>= fmap Wrap . go
     where
       go :: Int -> Gen Aeson.Value
-      go 0  = oneof nonRecursive
-      go sz = oneof (nonRecursive ++ recursive sz)
+      go 0  = QC.oneof nonRecursive
+      go sz = QC.oneof (nonRecursive ++ recursive sz)
 
       nonRecursive :: [Gen Aeson.Value]
       nonRecursive = [
@@ -249,9 +242,9 @@
 
       recursive :: Int -> [Gen Aeson.Value]
       recursive sz = [
-            do n <- choose (0, 5)
+            do n <- QC.choose (0, 5)
                Aeson.Array . Vector.Boxed.fromList <$> replicateM n (go (sz `div` n))
-          , do n <- choose (0, 5)
+          , do n <- QC.choose (0, 5)
                Aeson.object <$> replicateM n (
                        (Aeson..=)
                    <$> (fromString <$> fieldName)
@@ -261,12 +254,12 @@
 
       -- We're not interested in testing crazy values
       fieldName :: Gen String
-      fieldName = elements ["a", "b", "c"]
+      fieldName = QC.elements ["a", "b", "c"]
 
 -- | Rather than trying to be clever here, we just generate a handful of
 -- examples in different categories.
 instance Arbitrary (Wrap SomeFun) where
-  arbitrary = fmap Wrap $ elements [
+  arbitrary = fmap Wrap $ QC.elements [
         -- Parametrically polymorphic function
         fun (id    :: Int -> Int)
       , fun (const :: Int -> Bool -> Int)
@@ -282,7 +275,7 @@
       fun = unsafeCoerce
 
 instance Arbitrary (Wrap SomeStorableVector) where
-  arbitrary = fmap Wrap $ elements [
+  arbitrary = fmap Wrap $ QC.elements [
         some $ Vector.Storable.fromList ([1, 2, 3] :: [Int])
       , some $ Vector.Storable.fromList ("abc"     :: String)
       ]
@@ -291,7 +284,7 @@
       some = unsafeCoerce
 
 instance Arbitrary (Wrap SomePrimitiveVector) where
-  arbitrary = fmap Wrap $ elements [
+  arbitrary = fmap Wrap $ QC.elements [
         some $ Vector.Primitive.fromList ([1, 2, 3] :: [Int])
       , some $ Vector.Primitive.fromList ("abc"     :: String)
       ]
diff --git a/tests/Test/RecoverRTTI/QuickCheck/DepGen.hs b/tests/Test/RecoverRTTI/QuickCheck/DepGen.hs
--- a/tests/Test/RecoverRTTI/QuickCheck/DepGen.hs
+++ b/tests/Test/RecoverRTTI/QuickCheck/DepGen.hs
@@ -1,14 +1,3 @@
-{-# LANGUAGE DataKinds             #-}
-{-# LANGUAGE FlexibleContexts      #-}
-{-# LANGUAGE GADTs                 #-}
-{-# LANGUAGE KindSignatures        #-}
-{-# LANGUAGE NamedFieldPuns        #-}
-{-# LANGUAGE QuantifiedConstraints #-}
-{-# LANGUAGE RankNTypes            #-}
-{-# LANGUAGE ScopedTypeVariables   #-}
-{-# LANGUAGE TypeApplications      #-}
-{-# LANGUAGE UndecidableInstances  #-}
-
 module Test.RecoverRTTI.QuickCheck.DepGen (
     -- * Dependent generator
     DepGen(..)
@@ -41,8 +30,7 @@
 
 import Test.RecoverRTTI.Prim
 import Test.RecoverRTTI.QuickCheck.Sized (SizedGen)
-
-import qualified Test.RecoverRTTI.QuickCheck.Sized as SG
+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG
 
 {-------------------------------------------------------------------------------
   Dependent generator
diff --git a/tests/Test/RecoverRTTI/QuickCheck/Sized.hs b/tests/Test/RecoverRTTI/QuickCheck/Sized.hs
--- a/tests/Test/RecoverRTTI/QuickCheck/Sized.hs
+++ b/tests/Test/RecoverRTTI/QuickCheck/Sized.hs
@@ -1,15 +1,3 @@
-{-# LANGUAGE DataKinds                  #-}
-{-# LANGUAGE DeriveFunctor              #-}
-{-# LANGUAGE DerivingStrategies         #-}
-{-# LANGUAGE FlexibleContexts           #-}
-{-# LANGUAGE GADTs                      #-}
-{-# LANGUAGE GeneralizedNewtypeDeriving #-}
-{-# LANGUAGE KindSignatures             #-}
-{-# LANGUAGE RankNTypes                 #-}
-{-# LANGUAGE ScopedTypeVariables        #-}
-{-# LANGUAGE TypeApplications           #-}
-{-# LANGUAGE TypeOperators              #-}
-
 -- | Sized generators
 --
 -- Intended for qualified import
@@ -48,8 +36,7 @@
 import Debug.RecoverRTTI
 
 import Test.QuickCheck (Arbitrary, Gen)
-
-import qualified Test.QuickCheck as QC
+import Test.QuickCheck qualified as QC
 
 {-------------------------------------------------------------------------------
   Sized generators
diff --git a/tests/Test/RecoverRTTI/Sanity.hs b/tests/Test/RecoverRTTI/Sanity.hs
--- a/tests/Test/RecoverRTTI/Sanity.hs
+++ b/tests/Test/RecoverRTTI/Sanity.hs
@@ -1,7 +1,3 @@
-{-# LANGUAGE DerivingVia        #-}
-{-# LANGUAGE FlexibleInstances  #-}
-{-# LANGUAGE StandaloneDeriving #-}
-
 module Test.RecoverRTTI.Sanity (tests) where
 
 import Data.SOP.BasicFunctors
@@ -12,12 +8,13 @@
 
 import Test.Tasty
 import Test.Tasty.HUnit
-import Test.Tasty.QuickCheck
+import Test.Tasty.QuickCheck (testProperty)
+import Test.QuickCheck (Property)
+import Test.QuickCheck qualified as QC
 
 import Test.RecoverRTTI.ConcreteClassifier
 import Test.RecoverRTTI.QuickCheck.DepGen
-
-import qualified Test.RecoverRTTI.QuickCheck.Sized as SG
+import Test.RecoverRTTI.QuickCheck.Sized qualified as SG
 
 tests :: TestTree
 tests = testGroup "Test.RecoverRTTI.Sanity" [
@@ -28,10 +25,10 @@
 
 prop_typeSize :: Property
 prop_typeSize =
-    forAll (Blind <$> SG.run 10 arbitraryConcrete) $
-      \(Blind (Some (DepGen classifier _))) ->
-          counterexample ("classifier: " ++ show classifier)
-        $ counterexample ("size: " ++ show (sizeConcrete classifier))
+    QC.forAll (QC.Blind <$> SG.run 10 arbitraryConcrete) $
+      \(QC.Blind (Some (DepGen classifier _))) ->
+          QC.counterexample ("classifier: " ++ show classifier)
+        $ QC.counterexample ("size: " ++ show (sizeConcrete classifier))
         $ sizeConcrete classifier <= 100
 
 {-------------------------------------------------------------------------------
diff --git a/tests/Test/RecoverRTTI/Show.hs b/tests/Test/RecoverRTTI/Show.hs
--- a/tests/Test/RecoverRTTI/Show.hs
+++ b/tests/Test/RecoverRTTI/Show.hs
@@ -1,10 +1,10 @@
-{-# LANGUAGE NumericUnderscores #-}
-
 -- | Verify that 'anythingToString' produces same result as 'show'
 module Test.RecoverRTTI.Show (tests) where
 
 import Test.Tasty
-import Test.Tasty.QuickCheck hiding (classify)
+import Test.Tasty.QuickCheck (testProperty)
+import Test.QuickCheck (Property, (===))
+import Test.QuickCheck qualified as QC
 
 import Debug.RecoverRTTI
 
@@ -21,12 +21,12 @@
 -- This is a sanity check on the generator.
 prop_showGenerated :: Some Value -> Property
 prop_showGenerated (Some (Value _cc x)) =
-     counterexample ("length: " ++ show (length (show x)))
-   $ property (length (show x) < 1_000_000)
+     QC.counterexample ("length: " ++ show (length (show x)))
+   $ QC.property (length (show x) < 1_000_000)
 
 -- | Compare " normal " 'show' against the " recovered " 'show'
 prop_anythingToString :: Some Value -> Property
 prop_anythingToString (Some (Value _cc x)) =
-      counterexample ("inferred: " ++ show (classify x))
-    $ within 2_000_000
+      QC.counterexample ("inferred: " ++ show (classify x))
+    $ QC.within 2_000_000
     $ show x === anythingToString x
diff --git a/tests/Test/RecoverRTTI/Staged.hs b/tests/Test/RecoverRTTI/Staged.hs
--- a/tests/Test/RecoverRTTI/Staged.hs
+++ b/tests/Test/RecoverRTTI/Staged.hs
@@ -1,9 +1,3 @@
-{-# LANGUAGE DataKinds           #-}
-{-# LANGUAGE GADTs               #-}
-{-# LANGUAGE RankNTypes          #-}
-{-# LANGUAGE ScopedTypeVariables #-}
-{-# LANGUAGE TypeApplications    #-}
-
 -- | Staged inference
 --
 -- Suppose we have a user-defined type such as
diff --git a/tests/Test/RecoverRTTI/UserDefined.hs b/tests/Test/RecoverRTTI/UserDefined.hs
--- a/tests/Test/RecoverRTTI/UserDefined.hs
+++ b/tests/Test/RecoverRTTI/UserDefined.hs
@@ -1,12 +1,5 @@
-{-# LANGUAGE BangPatterns      #-}
-{-# LANGUAGE DataKinds         #-}
-{-# LANGUAGE DeriveGeneric     #-}
-{-# LANGUAGE DeriveTraversable #-}
-{-# LANGUAGE MagicHash         #-}
-{-# LANGUAGE PolyKinds         #-}
-{-# LANGUAGE TypeFamilies      #-}
-{-# LANGUAGE TypeOperators     #-}
-{-# LANGUAGE UnboxedTuples     #-}
+{-# LANGUAGE MagicHash     #-}
+{-# LANGUAGE UnboxedTuples #-}
 
 -- | Just some examples of user-defined types
 module Test.RecoverRTTI.UserDefined (
@@ -20,9 +13,10 @@
   ) where
 
 import Data.Proxy
+import GHC.Exts (RealWorld, MutableArray#, newArray#)
 import GHC.Generics
-import GHC.IO
-import GHC.Prim
+import GHC.IO (IO(..))
+import System.IO.Unsafe (unsafePerformIO)
 
 import Test.QuickCheck