diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,7 @@
+1.5.4 [2021.07.25]
+------------------
+* Allow building with `transformers-0.6.*`.
+
 1.5.3 [2020.12.30]
 ------------------
 * Explicitly mark modules as `Safe`.
diff --git a/contravariant.cabal b/contravariant.cabal
--- a/contravariant.cabal
+++ b/contravariant.cabal
@@ -1,6 +1,6 @@
 name:          contravariant
 category:      Control, Data
-version:       1.5.3
+version:       1.5.4
 license:       BSD3
 cabal-version: >= 1.10
 license-file:  LICENSE
@@ -23,8 +23,9 @@
              , GHC == 8.2.2
              , GHC == 8.4.4
              , GHC == 8.6.5
-             , GHC == 8.8.3
-             , GHC == 8.10.1
+             , GHC == 8.8.4
+             , GHC == 8.10.4
+             , GHC == 9.0.1
 extra-source-files:
   .hlint.yaml
   CHANGELOG.markdown
@@ -62,7 +63,7 @@
   hs-source-dirs: src
   build-depends:
     base                              < 5,
-    transformers        >= 0.3 &&     < 0.6
+    transformers        >= 0.3 &&     < 0.7
 
   if !impl(ghc > 7.10)
     build-depends: transformers-compat >= 0.5 && < 1
diff --git a/src/Data/Functor/Contravariant/Divisible.hs b/src/Data/Functor/Contravariant/Divisible.hs
--- a/src/Data/Functor/Contravariant/Divisible.hs
+++ b/src/Data/Functor/Contravariant/Divisible.hs
@@ -6,7 +6,9 @@
 {-# LANGUAGE Trustworthy #-}
 #endif
 
+#if !(MIN_VERSION_transformers(0,6,0))
 {-# OPTIONS_GHC -fno-warn-deprecations #-}
+#endif
 
 -----------------------------------------------------------------------------
 -- |
@@ -40,10 +42,8 @@
 import Control.Applicative
 import Control.Applicative.Backwards
 import Control.Arrow
-import Control.Monad.Trans.Error
 import Control.Monad.Trans.Except
 import Control.Monad.Trans.Identity
-import Control.Monad.Trans.List
 import Control.Monad.Trans.Maybe
 import qualified Control.Monad.Trans.RWS.Lazy as Lazy
 import qualified Control.Monad.Trans.RWS.Strict as Strict
@@ -53,7 +53,6 @@
 import qualified Control.Monad.Trans.Writer.Lazy as Lazy
 import qualified Control.Monad.Trans.Writer.Strict as Strict
 
-import Data.Either
 import Data.Functor.Compose
 import Data.Functor.Constant
 import Data.Functor.Contravariant
@@ -61,6 +60,12 @@
 import Data.Functor.Reverse
 import Data.Void
 
+#if !(MIN_VERSION_transformers(0,6,0))
+import Control.Monad.Trans.Error
+import Control.Monad.Trans.List
+import Data.Either
+#endif
+
 #if MIN_VERSION_base(4,8,0)
 import Data.Monoid (Alt(..))
 #else
@@ -241,10 +246,6 @@
   divide f (Backwards l) (Backwards r) = Backwards $ divide f l r
   conquer = Backwards conquer
 
-instance Divisible m => Divisible (ErrorT e m) where
-  divide f (ErrorT l) (ErrorT r) = ErrorT $ divide (funzip . fmap f) l r
-  conquer = ErrorT conquer
-
 instance Divisible m => Divisible (ExceptT e m) where
   divide f (ExceptT l) (ExceptT r) = ExceptT $ divide (funzip . fmap f) l r
   conquer = ExceptT conquer
@@ -253,10 +254,6 @@
   divide f (IdentityT l) (IdentityT r) = IdentityT $ divide f l r
   conquer = IdentityT conquer
 
-instance Divisible m => Divisible (ListT m) where
-  divide f (ListT l) (ListT r) = ListT $ divide (funzip . map f) l r
-  conquer = ListT conquer
-
 instance Divisible m => Divisible (MaybeT m) where
   divide f (MaybeT l) (MaybeT r) = MaybeT $ divide (funzip . fmap f) l r
   conquer = MaybeT conquer
@@ -422,7 +419,7 @@
       Right d -> h c d
 
 instance Decidable Equivalence where
-  lose f = Equivalence $ \a -> absurd (f a)
+  lose f = Equivalence $ absurd . f
   choose f (Equivalence g) (Equivalence h) = Equivalence $ \a b -> case f a of
     Left c -> case f b of
       Left d -> g c d
@@ -432,7 +429,7 @@
       Right d -> h c d
 
 instance Decidable Predicate where
-  lose f = Predicate $ \a -> absurd (f a)
+  lose f = Predicate $ absurd . f
   choose f (Predicate g) (Predicate h) = Predicate $ either g h . f
 
 instance Monoid r => Decidable (Op r) where
@@ -495,9 +492,19 @@
                                   (abc a))
            (rsmb r s) (rsmc r s)
 
+#if !(MIN_VERSION_transformers(0,6,0))
+instance Divisible m => Divisible (ErrorT e m) where
+  divide f (ErrorT l) (ErrorT r) = ErrorT $ divide (funzip . fmap f) l r
+  conquer = ErrorT conquer
+
+instance Divisible m => Divisible (ListT m) where
+  divide f (ListT l) (ListT r) = ListT $ divide (funzip . map f) l r
+  conquer = ListT conquer
+
 instance Divisible m => Decidable (ListT m) where
   lose _ = ListT conquer
   choose f (ListT l) (ListT r) = ListT $ divide ((lefts &&& rights) . map f) l r
+#endif
 
 instance Divisible m => Decidable (MaybeT m) where
   lose _ = MaybeT conquer