diff --git a/Control/Monad/Cont/Class.hs b/Control/Monad/Cont/Class.hs
--- a/Control/Monad/Cont/Class.hs
+++ b/Control/Monad/Cont/Class.hs
@@ -54,10 +54,8 @@
 
 import Control.Monad.Trans.Cont (ContT)
 import qualified Control.Monad.Trans.Cont as ContT
-import Control.Monad.Trans.Error as Error
 import Control.Monad.Trans.Except as Except
 import Control.Monad.Trans.Identity as Identity
-import Control.Monad.Trans.List as List
 import Control.Monad.Trans.Maybe as Maybe
 import Control.Monad.Trans.Reader as Reader
 import Control.Monad.Trans.RWS.Lazy as LazyRWS
@@ -73,9 +71,9 @@
     Provides an escape continuation mechanism for use with Continuation monads.
     Escape continuations allow to abort the current computation and return
     a value immediately.
-    They achieve a similar effect to 'Control.Monad.Error.throwError'
-    and 'Control.Monad.Error.catchError'
-    within an 'Control.Monad.Error.Error' monad.
+    They achieve a similar effect to 'Control.Monad.Except.throwError'
+    and 'Control.Monad.Except.catchError'
+    within a 'Control.Monad.Except.MonadError' monad.
     Advantage of this function over calling @return@ is that it makes
     the continuation explicit,
     allowing more flexibility and better control
@@ -94,17 +92,11 @@
 -- ---------------------------------------------------------------------------
 -- Instances for other mtl transformers
 
-instance (Error e, MonadCont m) => MonadCont (ErrorT e m) where
-    callCC = Error.liftCallCC callCC
-
 instance (MonadCont m) => MonadCont (ExceptT e m) where
     callCC = Except.liftCallCC callCC
 
 instance (MonadCont m) => MonadCont (IdentityT m) where
     callCC = Identity.liftCallCC callCC
-
-instance (MonadCont m) => MonadCont (ListT m) where
-    callCC = List.liftCallCC callCC
 
 instance (MonadCont m) => MonadCont (MaybeT m) where
     callCC = Maybe.liftCallCC callCC
diff --git a/Control/Monad/Error.hs b/Control/Monad/Error.hs
deleted file mode 100644
--- a/Control/Monad/Error.hs
+++ /dev/null
@@ -1,146 +0,0 @@
-{- |
-Module      :  Control.Monad.Error
-Copyright   :  (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001,
-               (c) Jeff Newbern 2003-2006,
-               (c) Andriy Palamarchuk 2006
-License     :  BSD-style (see the file LICENSE)
-
-Maintainer  :  ross@soi.city.ac.uk
-Stability   :  experimental
-Portability :  non-portable (type families)
-
-[Computation type:] Computations which may fail or throw exceptions.
-
-[Binding strategy:] Failure records information about the cause\/location
-of the failure. Failure values bypass the bound function,
-other values are used as inputs to the bound function.
-
-[Useful for:] Building computations from sequences of functions that may fail
-or using exception handling to structure error handling.
-
-[Zero and plus:] Zero is represented by an empty error and the plus operation
-executes its second argument if the first fails.
-
-[Example type:] @'Data.Either' String a@
-
-The Error monad (also called the Exception monad).
--}
-
-{-
-  Rendered by Michael Weber <mailto:michael.weber@post.rwth-aachen.de>,
-  inspired by the Haskell Monad Template Library from
-    Andy Gill (<http://web.cecs.pdx.edu/~andy/>)
--}
-module Control.Monad.Error
-  {-# DEPRECATED "Use Control.Monad.Except instead" #-}
-  (
-    -- * Monads with error handling
-    MonadError(..),
-    Error,
-    -- * The ErrorT monad transformer
-    ErrorT(..),
-    mapErrorT,
-    module Control.Monad,
-    module Control.Monad.Fix,
-    module Control.Monad.Trans,
-    -- * Example 1: Custom Error Data Type
-    -- $customErrorExample
-
-    -- * Example 2: Using ErrorT Monad Transformer
-    -- $ErrorTExample
-  ) where
-
-import Control.Monad.Error.Class
-import Control.Monad.Trans
-import Control.Monad.Trans.Error (ErrorT(..), mapErrorT)
-
-import Control.Monad
-import Control.Monad.Fix
-
-{- $customErrorExample
-Here is an example that demonstrates the use of a custom 'Error' data type with
-the 'throwError' and 'catchError' exception mechanism from 'MonadError'.
-The example throws an exception if the user enters an empty string
-or a string longer than 5 characters. Otherwise it prints length of the string.
-
->-- This is the type to represent length calculation error.
->data LengthError = EmptyString  -- Entered string was empty.
->          | StringTooLong Int   -- A string is longer than 5 characters.
->                                -- Records a length of the string.
->          | OtherError String   -- Other error, stores the problem description.
->
->-- We make LengthError an instance of the Error class
->-- to be able to throw it as an exception.
->instance Error LengthError where
->  noMsg    = OtherError "A String Error!"
->  strMsg s = OtherError s
->
->-- Converts LengthError to a readable message.
->instance Show LengthError where
->  show EmptyString = "The string was empty!"
->  show (StringTooLong len) =
->      "The length of the string (" ++ (show len) ++ ") is bigger than 5!"
->  show (OtherError msg) = msg
->
->-- For our monad type constructor, we use Either LengthError
->-- which represents failure using Left LengthError
->-- or a successful result of type a using Right a.
->type LengthMonad = Either LengthError
->
->main = do
->  putStrLn "Please enter a string:"
->  s <- getLine
->  reportResult (calculateLength s)
->
->-- Wraps length calculation to catch the errors.
->-- Returns either length of the string or an error.
->calculateLength :: String -> LengthMonad Int
->calculateLength s = (calculateLengthOrFail s) `catchError` Left
->
->-- Attempts to calculate length and throws an error if the provided string is
->-- empty or longer than 5 characters.
->-- The processing is done in Either monad.
->calculateLengthOrFail :: String -> LengthMonad Int
->calculateLengthOrFail [] = throwError EmptyString
->calculateLengthOrFail s | len > 5 = throwError (StringTooLong len)
->                        | otherwise = return len
->  where len = length s
->
->-- Prints result of the string length calculation.
->reportResult :: LengthMonad Int -> IO ()
->reportResult (Right len) = putStrLn ("The length of the string is " ++ (show len))
->reportResult (Left e) = putStrLn ("Length calculation failed with error: " ++ (show e))
--}
-
-{- $ErrorTExample
-@'ErrorT'@ monad transformer can be used to add error handling to another monad.
-Here is an example how to combine it with an @IO@ monad:
-
->import Control.Monad.Error
->
->-- An IO monad which can return String failure.
->-- It is convenient to define the monad type of the combined monad,
->-- especially if we combine more monad transformers.
->type LengthMonad = ErrorT String IO
->
->main = do
->  -- runErrorT removes the ErrorT wrapper
->  r <- runErrorT calculateLength
->  reportResult r
->
->-- Asks user for a non-empty string and returns its length.
->-- Throws an error if user enters an empty string.
->calculateLength :: LengthMonad Int
->calculateLength = do
->  -- all the IO operations have to be lifted to the IO monad in the monad stack
->  liftIO $ putStrLn "Please enter a non-empty string: "
->  s <- liftIO getLine
->  if null s
->    then throwError "The string was empty!"
->    else return $ length s
->
->-- Prints result of the string length calculation.
->reportResult :: Either String Int -> IO ()
->reportResult (Right len) = putStrLn ("The length of the string is " ++ (show len))
->reportResult (Left e) = putStrLn ("Length calculation failed with error: " ++ (show e))
--}
diff --git a/Control/Monad/Error/Class.hs b/Control/Monad/Error/Class.hs
deleted file mode 100644
--- a/Control/Monad/Error/Class.hs
+++ /dev/null
@@ -1,160 +0,0 @@
-{- |
-Module      :  Control.Monad.Error.Class
-Copyright   :  (c) Michael Weber <michael.weber@post.rwth-aachen.de> 2001,
-               (c) Jeff Newbern 2003-2006,
-               (c) Andriy Palamarchuk 2006
-License     :  BSD-style (see the file LICENSE)
-
-Maintainer  :  ross@soi.city.ac.uk
-Stability   :  experimental
-Portability :  non-portable (type families)
-
-[Computation type:] Computations which may fail or throw exceptions.
-
-[Binding strategy:] Failure records information about the cause\/location
-of the failure. Failure values bypass the bound function,
-other values are used as inputs to the bound function.
-
-[Useful for:] Building computations from sequences of functions that may fail
-or using exception handling to structure error handling.
-
-[Zero and plus:] Zero is represented by an empty error and the plus operation
-executes its second argument if the first fails.
-
-[Example type:] @'Either' 'String' a@
-
-The Error monad (also called the Exception monad).
--}
-
-{-
-  Rendered by Michael Weber <mailto:michael.weber@post.rwth-aachen.de>,
-  inspired by the Haskell Monad Template Library from
-    Andy Gill (<http://web.cecs.pdx.edu/~andy/>)
--}
-module Control.Monad.Error.Class
-  {-# DEPRECATED "Use Control.Monad.Except.Class instead" #-}
-  (
-    Error(..),
-    MonadError(..),
-  ) where
-
-import Control.Monad.Trans.Error (Error(..), ErrorT)
-import qualified Control.Monad.Trans.Error as ErrorT (throwError, catchError)
-import Control.Monad.Trans.Identity as Identity
-import Control.Monad.Trans.List as List
-import Control.Monad.Trans.Maybe as Maybe
-import Control.Monad.Trans.Reader as Reader
-import Control.Monad.Trans.RWS.Lazy as LazyRWS
-import Control.Monad.Trans.RWS.Strict as StrictRWS
-import Control.Monad.Trans.State.Lazy as LazyState
-import Control.Monad.Trans.State.Strict as StrictState
-import Control.Monad.Trans.Writer.Lazy as LazyWriter
-import Control.Monad.Trans.Writer.Strict as StrictWriter
-import Control.Monad.Trans
-
-import qualified Control.Exception
-
-{- |
-The strategy of combining computations that can throw exceptions
-by bypassing bound functions
-from the point an exception is thrown to the point that it is handled.
-
-Is parameterized over the type of error information and
-the monad type constructor.
-It is common to use @'Data.Either' String@ as the monad type constructor
-for an error monad in which error descriptions take the form of strings.
-In that case and many other common cases the resulting monad is already defined
-as an instance of the 'MonadError' class.
-You can also define your own error type and\/or use a monad type constructor
-other than @'Data.Either' String@ or @'Data.Either' IOError@.
-In these cases you will have to explicitly define instances of the 'Error'
-and\/or 'MonadError' classes.
--}
-class (Monad m) => MonadError m where
-    type ErrorType m
-
-    -- | Is used within a monadic computation to begin exception processing.
-    throwError :: ErrorType m -> m a
-
-    {- |
-    A handler function to handle previous errors and return to normal execution.
-    A common idiom is:
-
-    > do { action1; action2; action3 } `catchError` handler
-
-    where the @action@ functions can call 'throwError'.
-    Note that @handler@ and the do-block must have the same return type.
-    -}
-    catchError :: m a -> (ErrorType m -> m a) -> m a
-
-instance MonadError IO where
-    type ErrorType IO = IOError
-    throwError = ioError
-    catchError = Control.Exception.catch
-
--- ---------------------------------------------------------------------------
--- Our parameterizable error monad
-
-instance (Error e) => MonadError (Either e) where
-    type ErrorType (Either e) = e
-    throwError             = Left
-    Left  l `catchError` h = h l
-    Right r `catchError` _ = Right r
-
-instance (Monad m, Error e) => MonadError (ErrorT e m) where
-    type ErrorType (ErrorT e m) = e
-    throwError = ErrorT.throwError
-    catchError = ErrorT.catchError
-
--- ---------------------------------------------------------------------------
--- Instances for other mtl transformers
-
-instance (MonadError m) => MonadError (IdentityT m) where
-    type ErrorType (IdentityT m) = ErrorType m
-    throwError = lift . throwError
-    catchError = Identity.liftCatch catchError
-
-instance (MonadError m) => MonadError (ListT m) where
-    type ErrorType (ListT m) = ErrorType m
-    throwError = lift . throwError
-    catchError = List.liftCatch catchError
-
-instance (MonadError m) => MonadError (MaybeT m) where
-    type ErrorType (MaybeT m) = ErrorType m
-    throwError = lift . throwError
-    catchError = Maybe.liftCatch catchError
-
-instance (MonadError m) => MonadError (ReaderT r m) where
-    type ErrorType (ReaderT r m) = ErrorType m
-    throwError = lift . throwError
-    catchError = Reader.liftCatch catchError
-
-instance (Monoid w, MonadError m) => MonadError (LazyRWS.RWST r w s m) where
-    type ErrorType (LazyRWS.RWST r w s m) = ErrorType m
-    throwError = lift . throwError
-    catchError = LazyRWS.liftCatch catchError
-
-instance (Monoid w, MonadError m) => MonadError (StrictRWS.RWST r w s m) where
-    type ErrorType (StrictRWS.RWST r w s m) = ErrorType m
-    throwError = lift . throwError
-    catchError = StrictRWS.liftCatch catchError
-
-instance (MonadError m) => MonadError (LazyState.StateT s m) where
-    type ErrorType (LazyState.StateT s m) = ErrorType m
-    throwError = lift . throwError
-    catchError = LazyState.liftCatch catchError
-
-instance (MonadError m) => MonadError (StrictState.StateT s m) where
-    type ErrorType (StrictState.StateT s m) = ErrorType m
-    throwError = lift . throwError
-    catchError = StrictState.liftCatch catchError
-
-instance (Monoid w, MonadError m) => MonadError (LazyWriter.WriterT w m) where
-    type ErrorType (LazyWriter.WriterT w m) = ErrorType m
-    throwError = lift . throwError
-    catchError = LazyWriter.liftCatch catchError
-
-instance (Monoid w, MonadError m) => MonadError (StrictWriter.WriterT w m) where
-    type ErrorType (StrictWriter.WriterT w m) = ErrorType m
-    throwError = lift . throwError
-    catchError = StrictWriter.liftCatch catchError
diff --git a/Control/Monad/Except/Class.hs b/Control/Monad/Except/Class.hs
--- a/Control/Monad/Except/Class.hs
+++ b/Control/Monad/Except/Class.hs
@@ -38,7 +38,6 @@
 import Control.Monad.Trans.Except (ExceptT)
 import qualified Control.Monad.Trans.Except as ExceptT (throwE, catchE)
 import Control.Monad.Trans.Identity as Identity
-import Control.Monad.Trans.List as List
 import Control.Monad.Trans.Maybe as Maybe
 import Control.Monad.Trans.Reader as Reader
 import Control.Monad.Trans.RWS.Lazy as LazyRWS
diff --git a/Control/Monad/List.hs b/Control/Monad/List.hs
deleted file mode 100644
--- a/Control/Monad/List.hs
+++ /dev/null
@@ -1,27 +0,0 @@
------------------------------------------------------------------------------
--- |
--- Module      :  Control.Monad.List
--- Copyright   :  (c) Andy Gill 2001,
---                (c) Oregon Graduate Institute of Science and Technology, 2001
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  ross@soi.city.ac.uk
--- Stability   :  experimental
--- Portability :  portable
---
--- The List monad.
---
------------------------------------------------------------------------------
-
-module Control.Monad.List
-  {-# DEPRECATED "This transformer is invalid on most monads" #-}
-  (
-    ListT(..),
-    mapListT,
-    module Control.Monad,
-    module Control.Monad.Trans,
-  ) where
-
-import Control.Monad
-import Control.Monad.Trans
-import Control.Monad.Trans.List
diff --git a/Control/Monad/RWS/Class.hs b/Control/Monad/RWS/Class.hs
--- a/Control/Monad/RWS/Class.hs
+++ b/Control/Monad/RWS/Class.hs
@@ -30,7 +30,6 @@
 import Control.Monad.State.Class
 import Control.Monad.Writer.Class
 
-import Control.Monad.Trans.Error(Error, ErrorT)
 import Control.Monad.Trans.Except(ExceptT)
 import Control.Monad.Trans.Maybe(MaybeT)
 import Control.Monad.Trans.Identity(IdentityT)
@@ -46,8 +45,6 @@
 
 ---------------------------------------------------------------------------
 -- Instances for other mtl transformers
-
-instance (Error e, MonadRWS m) => MonadRWS (ErrorT e m)
 
 instance (MonadRWS m) => MonadRWS (ExceptT e m)
 
diff --git a/Control/Monad/Reader/Class.hs b/Control/Monad/Reader/Class.hs
--- a/Control/Monad/Reader/Class.hs
+++ b/Control/Monad/Reader/Class.hs
@@ -41,10 +41,8 @@
     ) where
 
 import Control.Monad.Trans.Cont as Cont
-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 Control.Monad.Trans.Reader (ReaderT)
 import qualified Control.Monad.Trans.Reader as ReaderT (ask, local)
@@ -114,11 +112,6 @@
     ask   = lift ask
     local = Cont.liftLocal ask local
 
-instance (Error e, MonadReader m) => MonadReader (ErrorT e m) where
-    type EnvType (ErrorT e m) = EnvType m
-    ask   = lift ask
-    local = mapErrorT . local
-
 instance (MonadReader m) => MonadReader (ExceptT e m) where
     type EnvType (ExceptT e m) = EnvType m
     ask   = lift ask
@@ -128,11 +121,6 @@
     type EnvType (IdentityT m) = EnvType m
     ask   = lift ask
     local = mapIdentityT . local
-
-instance (MonadReader m) => MonadReader (ListT m) where
-    type EnvType (ListT m) = EnvType m
-    ask   = lift ask
-    local = mapListT . local
 
 instance (MonadReader m) => MonadReader (MaybeT m) where
     type EnvType (MaybeT m) = EnvType m
diff --git a/Control/Monad/State/Class.hs b/Control/Monad/State/Class.hs
--- a/Control/Monad/State/Class.hs
+++ b/Control/Monad/State/Class.hs
@@ -27,10 +27,8 @@
 
 import Control.Monad.Trans (lift)
 import Control.Monad.Trans.Cont
-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 Control.Monad.Trans.Reader
 import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS (RWST, get, put)
@@ -103,11 +101,6 @@
     get = lift get
     put = lift . put
 
-instance (Error e, MonadState m) => MonadState (ErrorT e m) where
-    type StateType (ErrorT e m) = StateType m
-    get = lift get
-    put = lift . put
-
 instance (MonadState m) => MonadState (ExceptT e m) where
     type StateType (ExceptT e m) = StateType m
     get = lift get
@@ -115,11 +108,6 @@
 
 instance (MonadState m) => MonadState (IdentityT m) where
     type StateType (IdentityT m) = StateType m
-    get = lift get
-    put = lift . put
-
-instance (MonadState m) => MonadState (ListT m) where
-    type StateType (ListT m) = StateType m
     get = lift get
     put = lift . put
 
diff --git a/Control/Monad/Writer/Class.hs b/Control/Monad/Writer/Class.hs
--- a/Control/Monad/Writer/Class.hs
+++ b/Control/Monad/Writer/Class.hs
@@ -24,7 +24,6 @@
     censor,
   ) where
 
-import Control.Monad.Trans.Error as Error
 import Control.Monad.Trans.Except as Except
 import Control.Monad.Trans.Identity as Identity
 import Control.Monad.Trans.Maybe as Maybe
@@ -95,12 +94,6 @@
 
 -- ---------------------------------------------------------------------------
 -- Instances for other mtl transformers
-
-instance (Error e, MonadWriter m) => MonadWriter (ErrorT e m) where
-    type WriterType (ErrorT e m) = WriterType m
-    tell   = lift . tell
-    listen = Error.liftListen listen
-    pass   = Error.liftPass pass
 
 instance (MonadWriter m) => MonadWriter (ExceptT e m) where
     type WriterType (ExceptT e m) = WriterType m
diff --git a/changelog.md b/changelog.md
--- a/changelog.md
+++ b/changelog.md
@@ -1,3 +1,17 @@
+## 0.3.0.0
+
+Remove deprecated modules:
+
+* `Control.Monad.Error`
+* `Control.Monad.Error.Class`
+* `Control.Monad.List`
+
+Add support for `transformers-0.6.*`
+
+Published by: Chris Martin
+
+Date: 2023-07-10
+
 ## 0.2.1.0
 
 Add `MonadCont`, `MonadReader`, `MonadState`, `MonadRWS`,
diff --git a/monads-tf.cabal b/monads-tf.cabal
--- a/monads-tf.cabal
+++ b/monads-tf.cabal
@@ -1,7 +1,7 @@
 cabal-version: 3.0
 
 name:         monads-tf
-version:      0.2.1.0
+version:      0.3.0.0
 license:      BSD-3-Clause
 license-file: LICENSE
 author:       Andy Gill
@@ -20,12 +20,9 @@
   exposed-modules:
     Control.Monad.Cont
     Control.Monad.Cont.Class
-    Control.Monad.Error
-    Control.Monad.Error.Class
     Control.Monad.Except
     Control.Monad.Except.Class
     Control.Monad.Identity
-    Control.Monad.List
     Control.Monad.RWS
     Control.Monad.RWS.Class
     Control.Monad.RWS.Lazy
@@ -43,7 +40,7 @@
     Control.Monad.Writer.Strict
   build-depends:
     , base ^>= 4.16 || ^>= 4.17 || ^>= 4.18
-    , transformers ^>= 0.5.6
+    , transformers ^>= 0.5.6 || ^>= 0.6
   default-extensions:
     TypeFamilies
   default-language: GHC2021