diff --git a/data-dword.cabal b/data-dword.cabal
--- a/data-dword.cabal
+++ b/data-dword.cabal
@@ -1,5 +1,5 @@
 Name: data-dword
-Version: 0.3.2
+Version: 0.3.2.1
 Category: Data
 Stability: experimental
 Synopsis: Stick two binary words together to get a bigger one
@@ -21,7 +21,8 @@
   README.md
 
 Tested-With: GHC==7.6.3, GHC==7.8.4, GHC==7.10.3, GHC==8.0.2, GHC==8.2.2,
-             GHC==8.4.4, GHC==8.6.5, GHC==8.8.3, GHC==8.10.1
+             GHC==8.4.4, GHC==8.6.5, GHC==8.8.4, GHC==8.10.7, GHC==9.0.1,
+             GHC==9.2.1
 
 Cabal-Version: >= 1.10.0
 Build-Type: Simple
diff --git a/src/Data/DoubleWord/TH.hs b/src/Data/DoubleWord/TH.hs
--- a/src/Data/DoubleWord/TH.hs
+++ b/src/Data/DoubleWord/TH.hs
@@ -24,7 +24,7 @@
 #if !MIN_VERSION_base(4,12,0)
 import Control.Applicative ((<$>), (<*>))
 #endif
-import Language.Haskell.TH hiding (unpacked, match)
+import Language.Haskell.TH hiding (unpacked, match, conP)
 import Data.BinaryWord (BinaryWord(..))
 import Data.DoubleWord.Base
 
@@ -157,7 +157,7 @@
         -}
         [ funHiLo2 'compare $
             CaseE (appVN 'compare [hi, hi'])
-              [ Match (ConP 'EQ []) (NormalB (appVN 'compare [lo, lo'])) []
+              [ Match (conP 'EQ []) (NormalB (appVN 'compare [lo, lo'])) []
               , Match (VarP x) (NormalB (VarE x)) [] ]
         , inlinable 'compare ]
     , inst ''Bounded [tp]
@@ -213,10 +213,10 @@
           fromEnum _           = ERROR
         -}
         , FunD 'fromEnum $
-            Clause [ConP cn [LitP $ IntegerL 0, VarP lo]]
+            Clause [conP cn [LitP $ IntegerL 0, VarP lo]]
                    (NormalB $ appVN 'fromEnum [lo]) [] :
             if signed
-            then [ Clause [ConP cn [LitP $ IntegerL (-1), VarP lo]]
+            then [ Clause [conP cn [LitP $ IntegerL (-1), VarP lo]]
                           (NormalB $
                              appV 'negate
                                [appV 'fromEnum [appV 'negate [VarE lo]]])
@@ -257,9 +257,9 @@
               [VarP x, VarP y]
               (NormalB $
                  CaseE (appVN 'compare [y, x])
-                   [ match (ConP 'LT []) (ConE '[])
-                   , match (ConP 'EQ []) (singE $ VarE x)
-                   , match (ConP 'GT []) $ appC '(:) [VarE x, appVN up [y, x]]
+                   [ match (conP 'LT []) (ConE '[])
+                   , match (conP 'EQ []) (singE $ VarE x)
+                   , match (conP 'GT []) $ appC '(:) [VarE x, appVN up [y, x]]
                    ])
               [ FunD up $ return $
                   Clause [VarP to, VarP c]
@@ -292,7 +292,7 @@
               (NormalB $
                 CaseE (appVN 'compare [y, x])
                   [ match'
-                      (ConP 'LT [])
+                      (conP 'LT [])
                       (CondE (appVN '(>) [z, y])
                              (CondE (appVN '(>) [z, x])
                                     (ConE '[]) (singE $ VarE x))
@@ -308,11 +308,11 @@
                                       ])
                       ]
                   , match
-                      (ConP 'EQ [])
+                      (conP 'EQ [])
                       (CondE (appVN '(<) [z, x])
                              (ConE '[]) (appVN 'repeat [x]))
                   , match'
-                      (ConP 'GT [])
+                      (conP 'GT [])
                       (CondE (appVN '(<) [z, y])
                              (CondE (appVN '(<) [z, x])
                                     (ConE '[]) (singE $ VarE x))
@@ -363,13 +363,13 @@
         , funHiLo 'signum $
             if signed
             then CaseE (appVN 'compare [hi, 'allZeroes])
-                   [ Match (ConP 'LT [])
+                   [ Match (conP 'LT [])
                            (NormalB $ appWN ['allOnes, 'maxBound]) []
-                   , Match (ConP 'EQ [])
+                   , Match (conP 'EQ [])
                            (NormalB $ CondE (appVN '(==) [lo, 'allZeroes])
                                             zeroE oneE)
                            []
-                   , Match (ConP 'GT []) (NormalB oneE) []
+                   , Match (conP 'GT []) (NormalB oneE) []
                    ]
             else CondE (appV '(&&) [ appVN '(==) [hi, 'allZeroes]
                                    , appVN '(==) [lo, 'allZeroes] ])
@@ -585,22 +585,22 @@
                                  , appVN '(==) [lo', 'allZeroes] ])
                  (appV 'error [litS "divide by zero"])
                  (CaseE (appVN 'compare [hi, hi'])
-                    [ match (ConP 'LT []) (tup [zeroE, VarE x])
-                    , match (ConP 'EQ [])
+                    [ match (conP 'LT []) (tup [zeroE, VarE x])
+                    , match (conP 'EQ [])
                         (CaseE (appVN 'compare [lo, lo'])
-                           [ match (ConP 'LT []) (tup [zeroE, VarE x])
-                           , match (ConP 'EQ []) (tup [oneE, zeroE])
-                           , Match (ConP 'GT [])
+                           [ match (conP 'LT []) (tup [zeroE, VarE x])
+                           , match (conP 'EQ []) (tup [oneE, zeroE])
+                           , Match (conP 'GT [])
                                (GuardedB $ return
                                   ( NormalG (appVN '(==) [hi', 'allZeroes])
                                   , tup [ appWN ['allZeroes, t2]
                                          , appWN ['allZeroes, t1] ]))
                                [vals [t2, t1] $ appVN 'quotRem [lo, lo']]
-                           , match (ConP 'GT []) $
+                           , match (conP 'GT []) $
                                tup [ oneE
                                     , appW [zeroE, appVN '(-) [lo, lo']] ]
                            ])
-                    , Match (ConP 'GT [])
+                    , Match (conP 'GT [])
                         (GuardedB $ return
                            ( NormalG (appVN '(==) [lo', 'allZeroes])
                            , tup
@@ -608,7 +608,7 @@
                                , appW [appVN 'fromIntegral [t1], VarE lo]
                                ] ))
                         [vals [t2, t1] $ appVN 'quotRem [hi, hi']]
-                    , Match (ConP 'GT [])
+                    , Match (conP 'GT [])
                         (GuardedB $ return
                            ( NormalG (appV '(&&)
                                         [ appVN '(==) [hi', 'allZeroes]
@@ -646,12 +646,12 @@
                            ))
                         [ val z $ appVN 'fromIntegral [hi]
                         , vals [t2, t1] $ appVN 'unwrappedAdd [z, lo] ]
-                    , Match (ConP 'GT [])
+                    , Match (conP 'GT [])
                         (GuardedB $ return
                            ( NormalG (appVN '(==) [hi', 'allZeroes])
                            , tup [VarE t2, appWN ['allZeroes, t1]] ))
                         [vals [t2, t1] $ appVN div1 [hi, lo, lo']]
-                    , match' (ConP 'GT [])
+                    , match' (conP 'GT [])
                         (CondE (appVN '(==) [t1, t2])
                                (tup [oneE, appVN '(-) [x, y]])
                                (tup [ appW [zeroE, appVN 'fromIntegral [q2]]
@@ -662,9 +662,9 @@
                                     [ VarE hi
                                     , appV '(-) [hiSizeE, VarE t2]
                                     ]
-                        , ValD (ConP cn [VarP hhh, VarP hll])
+                        , ValD (conP cn [VarP hhh, VarP hll])
                             (NormalB $ appVN 'shiftL [x, t2]) []
-                        , ValD (AsP v $ ConP cn [VarP lhh, VarP lll])
+                        , ValD (AsP v $ conP cn [VarP lhh, VarP lll])
                             (NormalB $ appVN 'shiftL [y, t2]) []
                         , ValD (TupP [ TupP [LitP (IntegerL 0), VarP q1]
                                      , VarP r1 ])
@@ -1412,23 +1412,23 @@
       FunD n [Clause [TupP [VarP x, VarP y], VarP z] (NormalB e) []]
     funTupLZ n e  =
       FunD n [Clause [TupP [VarP x, WildP], VarP z] (NormalB e) []]
-    funLo n e     = FunD n [Clause [ConP cn [WildP, VarP lo]] (NormalB e) []]
-    funHi n e     = FunD n [Clause [ConP cn [VarP hi, WildP]] (NormalB e) []]
+    funLo n e     = FunD n [Clause [conP cn [WildP, VarP lo]] (NormalB e) []]
+    funHi n e     = FunD n [Clause [conP cn [VarP hi, WildP]] (NormalB e) []]
     funHiLo n e   = funHiLo' n e []
     funHiLo' n e ds  =
-      FunD n [Clause [ConP cn [VarP hi, VarP lo]] (NormalB e) ds]
+      FunD n [Clause [conP cn [VarP hi, VarP lo]] (NormalB e) ds]
     funHiLoX' n e ds =
-      FunD n [Clause [ConP cn [VarP hi, VarP lo], VarP x] (NormalB e) ds]
+      FunD n [Clause [conP cn [VarP hi, VarP lo], VarP x] (NormalB e) ds]
     funHiLo2 n e     = funHiLo2' n e []
     funHiLo2' n e ds =
-      FunD n [Clause [ ConP cn [VarP hi, VarP lo]
-                     , ConP cn [VarP hi', VarP lo'] ]
+      FunD n [Clause [ conP cn [VarP hi, VarP lo]
+                     , conP cn [VarP hi', VarP lo'] ]
                      (NormalB e) ds]
     funHiLo2XY' n e ds =
-      FunD n [Clause [ AsP x (ConP cn [VarP hi, VarP lo])
-                     , AsP y (ConP cn [VarP hi', VarP lo']) ]
+      FunD n [Clause [ AsP x (conP cn [VarP hi, VarP lo])
+                     , AsP y (conP cn [VarP hi', VarP lo']) ]
                      (NormalB e) ds]
-    funXHiLo n e  = FunD n [Clause [VarP x, ConP cn [VarP hi, VarP lo]]
+    funXHiLo n e  = FunD n [Clause [VarP x, conP cn [VarP hi, VarP lo]]
                                    (NormalB e) []]
     match' p e ds = Match p (NormalB e) ds
     match p e     = match' p e []
@@ -1458,6 +1458,13 @@
     sizeE   = appV 'bitSize [SigE (VarE 'undefined) tpT]
 #endif
     singE e = appC '(:) [e, ConE '[]]
+    conP name ps =
+      ConP name
+#if MIN_VERSION_template_haskell(2,18,0)
+           [] ps
+#else
+           ps
+#endif
     ruleP name lhs rhs phases =
       RuleP name
 #if MIN_VERSION_template_haskell(2,15,0)
