diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,20 @@
 # Revision history for deriving-trans
 
+## 0.6.0.0 *23 Jan 2023*
+
+* Update dependencies:
+  - transformers `>= 0.6`
+  - exceptions `>= 0.4` (optional)
+  - mtl `>= 2.3` (optional)
+  - primitive (optional)
+  - resourcet `>= 1.2` (optional)
+  - unliftio (optional)
+* Add `MonadAccum` and `MonadSelect` instances to `Elevator` and `ComposeT`.
+* Add "base-case" instances for `AccumT` and `SelectT`.
+* Add "base-case" instances for the CPS versions of `WriterT` and `RWST`.
+* Remove `Monad m` constraint from "base-case" instance for `ContT`.
+* Add `MonadResource` instances to `Elevator` and `ComposeT` including a `ResourceT` "base-case" instance.
+
 ## 0.5.2.0 *17 Jan 2023*
 
 * Add optional dependency `primitive`.
diff --git a/deriving-trans.cabal b/deriving-trans.cabal
--- a/deriving-trans.cabal
+++ b/deriving-trans.cabal
@@ -1,6 +1,6 @@
 cabal-version: 3.0
 name: deriving-trans
-version: 0.5.2.0
+version: 0.6.0.0
 synopsis: Derive instances for monad transformer stacks
 description:
   Implementing instances for monad transformer stacks can be tedious.
@@ -40,6 +40,11 @@
   description:
     Implement instances for `PrimMonad`.
 
+flag resourcet
+  default: True
+  description:
+    Implement instances for `MonadResource`.
+
 flag unliftio
   default: True
   description:
@@ -52,22 +57,27 @@
     Control.Monad.Trans.Compose.Stack
     Control.Monad.Trans.Compose.Transparent
     Control.Monad.Trans.Elevator
-  --other-modules:
   build-depends:
     , base < 5
     , monad-control
     , monad-control-identity
-    , transformers
+    , transformers >= 0.6
     , transformers-base
   if flag(exceptions)
     build-depends:
-      , exceptions
+      , exceptions >= 0.4
   if flag(mtl)
+    other-modules:
+      Control.Monad.Accum.OrphanInstances
+      Control.Monad.Select.OrphanInstances
     build-depends:
-      , mtl
+      , mtl >= 2.3
   if flag(primitive)
     build-depends:
       , primitive
+  if flag(resourcet)
+    build-depends:
+      , resourcet >= 1.2
   if flag(unliftio)
     build-depends:
       , unliftio-core
@@ -88,6 +98,7 @@
     FlexibleInstances
     FunctionalDependencies
     GeneralizedNewtypeDeriving
+    ImportQualifiedPost
     MultiParamTypeClasses
     NamedFieldPuns
     OverloadedStrings
@@ -101,3 +112,4 @@
   ghc-options:
     -Wall
     -Wunused-packages
+    -Wredundant-constraints
diff --git a/src/Control/Monad/Accum/OrphanInstances.hs b/src/Control/Monad/Accum/OrphanInstances.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Accum/OrphanInstances.hs
@@ -0,0 +1,10 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Control.Monad.Accum.OrphanInstances where
+
+import Control.Monad.Accum
+import qualified Control.Monad.Trans.Accum as T
+
+instance (Monoid w, Monad m) => MonadAccum w (T.AccumT w m) where
+  look = T.look
+  add = T.add
diff --git a/src/Control/Monad/Select/OrphanInstances.hs b/src/Control/Monad/Select/OrphanInstances.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Monad/Select/OrphanInstances.hs
@@ -0,0 +1,12 @@
+{-# OPTIONS_GHC -fno-warn-orphans #-}
+
+module Control.Monad.Select.OrphanInstances where
+
+import Control.Monad.Select
+import Control.Monad.Trans.Control.Identity
+import qualified Control.Monad.Trans.Select as T
+import Data.Functor.Identity
+
+instance MonadBaseControlIdentity Identity m => MonadSelect r (T.SelectT r m) where
+  select f = T.SelectT $ \ k -> liftBaseWithIdentity $ \runInIdentity ->
+    Identity $ f $ runIdentity . runInIdentity . k
diff --git a/src/Control/Monad/Trans/Compose.hs b/src/Control/Monad/Trans/Compose.hs
--- a/src/Control/Monad/Trans/Compose.hs
+++ b/src/Control/Monad/Trans/Compose.hs
@@ -14,34 +14,47 @@
 import Data.Kind
 
 #if defined(VERSION_exceptions)
-import Control.Monad.Catch
-import qualified Control.Monad.Catch.Pure as T
+import Control.Monad.Catch qualified as Exceptions
+import Control.Monad.Catch.Pure qualified as Exceptions.T
 #endif
 
 #if defined(VERSION_mtl)
-import Control.Monad.Cont.Class
-import Control.Monad.Error.Class
-import Control.Monad.Reader.Class
-import Control.Monad.RWS.Class (MonadRWS)
-import Control.Monad.State.Class
-import qualified Control.Monad.Trans.Cont as T
-import qualified Control.Monad.Trans.Except as T
-import qualified Control.Monad.Trans.RWS.Lazy as LT
-import qualified Control.Monad.Trans.RWS.Strict as ST
-import qualified Control.Monad.Trans.Reader as T
-import qualified Control.Monad.Trans.State.Lazy as LT
-import qualified Control.Monad.Trans.State.Strict as ST
-import qualified Control.Monad.Trans.Writer.Lazy as LT
-import qualified Control.Monad.Trans.Writer.Strict as ST
-import Control.Monad.Writer.Class
+import Control.Monad.Accum qualified as Mtl
+import Control.Monad.Accum.OrphanInstances qualified as Mtl ()
+import Control.Monad.Cont.Class qualified as Mtl
+import Control.Monad.Error.Class qualified as Mtl
+import Control.Monad.Reader.Class qualified as Mtl
+import Control.Monad.RWS.Class qualified as Mtl (MonadRWS)
+import Control.Monad.Select qualified as Mtl
+import Control.Monad.Select.OrphanInstances qualified as Mtl ()
+import Control.Monad.State.Class qualified as Mtl
+import Control.Monad.Trans.Accum qualified as Mtl.T
+import Control.Monad.Trans.Cont qualified as Mtl.T
+import Control.Monad.Trans.Except qualified as Mtl.T
+import Control.Monad.Trans.RWS.CPS qualified as Mtl.CPST
+import Control.Monad.Trans.RWS.Lazy qualified as Mtl.LT
+import Control.Monad.Trans.RWS.Strict qualified as Mtl.ST
+import Control.Monad.Trans.Reader qualified as Mtl.T
+import Control.Monad.Trans.Select qualified as Mtl.T
+import Control.Monad.Trans.State.Lazy qualified as Mtl.LT
+import Control.Monad.Trans.State.Strict qualified as Mtl.ST
+import Control.Monad.Trans.Writer.CPS qualified as Mtl.CPST
+import Control.Monad.Trans.Writer.Lazy qualified as Mtl.LT
+import Control.Monad.Trans.Writer.Strict qualified as Mtl.ST
+import Control.Monad.Writer.Class qualified as Mtl
+import Data.Functor.Identity qualified as Mtl
 #endif
 
 #if defined(VERSION_primitive)
-import Control.Monad.Primitive
+import Control.Monad.Primitive qualified as Primitive
 #endif
 
+#if defined(VERSION_resourcet)
+import Control.Monad.Trans.Resource qualified as ResourceT
+#endif
+
 #if defined(VERSION_unliftio_core)
-import Control.Monad.IO.Unlift
+import Control.Monad.IO.Unlift qualified as UnliftIO
 #endif
 
 -- * 'ComposeT'
@@ -72,48 +85,44 @@
 newtype ComposeT t1 t2 m a = ComposeT { deComposeT :: t1 (t2 m) a }
   deriving newtype (Applicative, Functor, Monad)
 
-instance (forall m. Monad m => Monad (t2 m), MonadTrans t1, MonadTrans t2) => MonadTrans (ComposeT t1 t2) where
+instance (MonadTrans t1, MonadTrans t2) => MonadTrans (ComposeT t1 t2) where
   lift = ComposeT . lift . lift
 
-instance (forall m. Monad m => Monad (t2 m), MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2) where
+instance (MonadTransControl t1, MonadTransControl t2) => MonadTransControl (ComposeT t1 t2) where
   type StT (ComposeT t1 t2) a = StT t2 (StT t1 a)
   liftWith f = defaultLiftWith2 ComposeT deComposeT $ \ x -> f x
   restoreT = defaultRestoreT2 ComposeT
 
-instance (forall m. Monad m => Monad (t2 m), MonadTransControlIdentity t1, MonadTransControlIdentity t2) => MonadTransControlIdentity (ComposeT t1 t2) where
+instance (MonadTransControlIdentity t1, MonadTransControlIdentity t2) => MonadTransControlIdentity (ComposeT t1 t2) where
   liftWithIdentity inner = ComposeT $ liftWithIdentity $ \ runId1 ->
     liftWithIdentity $ \ runId2 -> inner $ runId2 . runId1 . deComposeT
 
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( MonadIO m
     , MonadTrans (ComposeT t1 t2)
-    , MonadIO m
     ) => MonadIO (ComposeT t1 t2 m)
 
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( MonadBase b m
     , MonadTrans (ComposeT t1 t2)
-    , MonadBase b m
     ) => MonadBase b (ComposeT t1 t2 m)
 
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( MonadBaseControl b m
     , MonadTransControl (ComposeT t1 t2)
-    , MonadBaseControl b m
     ) => MonadBaseControl b (ComposeT t1 t2 m)
 
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( MonadBaseControlIdentity b m
     , MonadTransControlIdentity (ComposeT t1 t2)
-    , MonadBaseControlIdentity b m
     ) => MonadBaseControlIdentity b (ComposeT t1 t2 m)
 
 #if defined(VERSION_exceptions)
@@ -121,31 +130,29 @@
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Exceptions.MonadThrow (t2 m)
     , MonadTrans t1
-    , MonadThrow (t2 m)
-    ) => MonadThrow (ComposeT t1 t2 m)
+    ) => Exceptions.MonadThrow (ComposeT t1 t2 m)
 
--- | Set by 'T.CatchT'.
-deriving via T.CatchT (t2 (m :: Type -> Type))
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    ) => MonadThrow (ComposeT T.CatchT t2 m)
+    ) => Exceptions.MonadThrow (ComposeT Exceptions.T.CatchT t2 m)
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Exceptions.MonadCatch (t2 m)
     , MonadTransControl t1
-    , MonadCatch (t2 m)
-    ) => MonadCatch (ComposeT t1 t2 m)
+    ) => Exceptions.MonadCatch (ComposeT t1 t2 m)
 
--- | Set by 'T.CatchT'.
-deriving via T.CatchT (t2 (m :: Type -> Type))
+-- | Set by 'Exceptions.T.CatchT'.
+deriving via Exceptions.T.CatchT (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    ) => MonadCatch (ComposeT T.CatchT t2 m)
+    ) => Exceptions.MonadCatch (ComposeT Exceptions.T.CatchT t2 m)
 #endif
 
 #if defined(VERSION_mtl)
@@ -153,177 +160,253 @@
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
-    , MonadTransControl t1
-    , MonadCont (t2 m)
-    ) => MonadCont (ComposeT t1 t2 m)
+    ( Mtl.MonadAccum w (t2 m)
+    , MonadTrans t1
+    ) => Mtl.MonadAccum w (ComposeT t1 t2 m)
 
--- | Set by 'T.ContT'.
-deriving via T.ContT r (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.T.AccumT'.
+deriving via Mtl.T.AccumT w (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    ) => MonadCont (ComposeT (T.ContT r) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadAccum w (ComposeT (Mtl.T.AccumT w) t2 m)
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Mtl.MonadCont (t2 m)
     , MonadTransControl t1
-    , MonadError e (t2 m)
-    ) => MonadError e (ComposeT t1 t2 m)
+    ) => Mtl.MonadCont (ComposeT t1 t2 m)
 
--- | Set by 'T.ExceptT'.
-deriving via T.ExceptT e (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.T.ContT'.
+deriving via Mtl.T.ContT r (t2 (m :: Type -> Type))
+  instance Mtl.MonadCont (ComposeT (Mtl.T.ContT r) t2 m)
+
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( Mtl.MonadError e (t2 m)
+    , MonadTransControl t1
+    ) => Mtl.MonadError e (ComposeT t1 t2 m)
+
+-- | Set by 'Mtl.T.ExceptT'.
+deriving via Mtl.T.ExceptT e (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    ) => MonadError e (ComposeT (T.ExceptT e) t2 m)
+    ) => Mtl.MonadError e (ComposeT (Mtl.T.ExceptT e) t2 m)
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Mtl.MonadReader r (t2 m)
     , MonadTransControl t1
-    , MonadReader r (t2 m)
-    ) => MonadReader r (ComposeT t1 t2 m)
+    ) => Mtl.MonadReader r (ComposeT t1 t2 m)
 
--- | Set by 'T.ReaderT'.
-deriving via T.ReaderT r (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.T.ReaderT'.
+deriving via Mtl.T.ReaderT r (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    ) => MonadReader r (ComposeT (T.ReaderT r) t2 m)
+    ) => Mtl.MonadReader r (ComposeT (Mtl.T.ReaderT r) t2 m)
 
--- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.CPST.RWST'.
+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadReader r (ComposeT (LT.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadReader r (ComposeT (Mtl.CPST.RWST r w s) t2 m)
 
--- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.LT.RWST'.
+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadReader r (ComposeT (ST.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadReader r (ComposeT (Mtl.LT.RWST r w s) t2 m)
 
+-- | Set by 'Mtl.ST.RWST'.
+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadReader r (ComposeT (Mtl.ST.RWST r w s) t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Mtl.MonadRWS r w s (t2 m)
     , MonadTransControl t1
-    , MonadRWS r w s (t2 m)
-    ) => MonadRWS r w s (ComposeT t1 t2 m)
+    ) => Mtl.MonadRWS r w s (ComposeT t1 t2 m)
 
--- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.CPST.RWST'.
+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadRWS r w s (ComposeT (LT.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.CPST.RWST r w s) t2 m)
 
--- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.LT.RWST'.
+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadRWS r w s (ComposeT (ST.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.LT.RWST r w s) t2 m)
 
+-- | Set by 'Mtl.ST.RWST'.
+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadRWS r w s (ComposeT (Mtl.ST.RWST r w s) t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Mtl.MonadSelect r (t2 m)
     , MonadTrans t1
-    , MonadState s (t2 m)
-    ) => MonadState s (ComposeT t1 t2 m)
+    ) => Mtl.MonadSelect r (ComposeT t1 t2 m)
 
--- | Set by 'LT.StateT'.
-deriving via LT.StateT s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.T.SelectT'.
+deriving via Mtl.T.SelectT r (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    ) => MonadState s (ComposeT (LT.StateT s) t2 m)
+    ( MonadBaseControlIdentity Mtl.Identity (t2 m)
+    ) => Mtl.MonadSelect r (ComposeT (Mtl.T.SelectT r) t2 m)
 
--- | Set by 'ST.StateT'.
-deriving via ST.StateT s (t2 (m :: Type -> Type))
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( Mtl.MonadState s (t2 m)
+    , MonadTrans t1
+    ) => Mtl.MonadState s (ComposeT t1 t2 m)
+
+-- | Set by 'Mtl.LT.StateT'.
+deriving via Mtl.LT.StateT s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    ) => MonadState s (ComposeT (ST.StateT s) t2 m)
+    ) => Mtl.MonadState s (ComposeT (Mtl.LT.StateT s) t2 m)
 
--- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.ST.StateT'.
+deriving via Mtl.ST.StateT s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
-    , Monoid w
-    ) => MonadState s (ComposeT (LT.RWST r w s) t2 m)
+    ) => Mtl.MonadState s (ComposeT (Mtl.ST.StateT s) t2 m)
 
--- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.CPST.RWST'.
+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadState s (ComposeT (ST.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadState s (ComposeT (Mtl.CPST.RWST r w s) t2 m)
 
+-- | Set by 'Mtl.LT.RWST'.
+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadState s (ComposeT (Mtl.LT.RWST r w s) t2 m)
+
+-- | Set by 'Mtl.ST.RWST'.
+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadState s (ComposeT (Mtl.ST.RWST r w s) t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
 deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
-    ( Monad (t1 (t2 m))
+    ( Mtl.MonadWriter w (t2 m)
     , MonadTransControl t1
-    , MonadWriter w (t2 m)
-    ) => MonadWriter w (ComposeT t1 t2 m)
+    ) => Mtl.MonadWriter w (ComposeT t1 t2 m)
 
--- | Set by 'LT.WriterT'.
-deriving via LT.WriterT w (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.CPST.WriterT'.
+deriving via Mtl.CPST.WriterT w (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadWriter w (ComposeT (LT.WriterT w) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.CPST.WriterT w) t2 m)
 
--- | Set by 'ST.WriterT'.
-deriving via ST.WriterT w (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.LT.WriterT'.
+deriving via Mtl.LT.WriterT w (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadWriter w (ComposeT (ST.WriterT w) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.LT.WriterT w) t2 m)
 
--- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.ST.WriterT'.
+deriving via Mtl.ST.WriterT w (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadWriter w (ComposeT (LT.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.ST.WriterT w) t2 m)
 
--- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: Type -> Type))
+-- | Set by 'Mtl.CPST.RWST'.
+deriving via Mtl.CPST.RWST r w s (t2 (m :: Type -> Type))
   instance
-    ( Monad (t2 m)
-    , Monoid w
-    ) => MonadWriter w (ComposeT (ST.RWST r w s) t2 m)
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.CPST.RWST r w s) t2 m)
+
+-- | Set by 'Mtl.LT.RWST'.
+deriving via Mtl.LT.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.LT.RWST r w s) t2 m)
+
+-- | Set by 'Mtl.ST.RWST'.
+deriving via Mtl.ST.RWST r w s (t2 (m :: Type -> Type))
+  instance
+    ( Monoid w
+    , Monad (t2 m)
+    ) => Mtl.MonadWriter w (ComposeT (Mtl.ST.RWST r w s) t2 m)
 #endif
 
 #if defined(VERSION_primitive)
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( Primitive.PrimMonad m
     , MonadTrans (ComposeT t1 t2)
-    , PrimMonad m
     ) =>
-    PrimMonad (ComposeT t1 t2 m)
+    Primitive.PrimMonad (ComposeT t1 t2 m)
 #endif
 
+#if defined(VERSION_resourcet)
+-- TODO: `MonadIO m` and `MonadTrans t2` should not be required for this instance
+-- | /OVERLAPPABLE/.
+-- Elevated to @(t2 m)@.
+deriving via Elevator t1 (t2 (m :: Type -> Type))
+  instance {-# OVERLAPPABLE #-}
+    ( ResourceT.MonadResource (t2 m)
+    , MonadTrans t1
+    , MonadIO m
+    , MonadTrans t2
+    ) => ResourceT.MonadResource (ComposeT t1 t2 m)
+
+-- TODO: `MonadIO m` and `MonadTrans t2` should not be required for this instance
+-- | Set by 'ResourceT.ResourceT'.
+deriving via ResourceT.ResourceT (t2 (m :: Type -> Type))
+  instance
+    ( MonadIO (t2 m)
+    , MonadIO m
+    , MonadTrans t2
+    ) => ResourceT.MonadResource (ComposeT ResourceT.ResourceT t2 m)
+#endif
+
 #if defined(VERSION_unliftio_core)
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
-    ( Monad (t1 (t2 m))
+    ( UnliftIO.MonadUnliftIO m
     , MonadTransControlIdentity (ComposeT t1 t2)
-    , MonadUnliftIO m
     ) =>
-    MonadUnliftIO (ComposeT t1 t2 m)
+    UnliftIO.MonadUnliftIO (ComposeT t1 t2 m)
 #endif
 
 
@@ -423,7 +506,7 @@
 -- Create a monad transformer stack and wrap it using a newtype.
 --
 -- @
--- type AppStackT = t'Control.Monad.Trans.Compose.Transparent.TransparentT' t'Control.Monad.Trans.Compose.Infix..|>' 'T.ReaderT' 'Bool' t'Control.Monad.Trans.Compose.Infix..|>' CustomT t'Control.Monad.Trans.Compose.Infix..|>' 'T.ReaderT' 'Char' t'Control.Monad.Trans.Compose.Infix..|>' 'LT.StateT' 'Int'
+-- type AppStackT = t'Control.Monad.Trans.Compose.Transparent.TransparentT' t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.Reader.ReaderT' 'Bool' t'Control.Monad.Trans.Compose.Infix..|>' CustomT t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.Reader.ReaderT' 'Char' t'Control.Monad.Trans.Compose.Infix..|>' 'Control.Monad.Trans.State.Lazy.StateT' 'Int'
 -- newtype AppT m a = AppT { unAppT :: AppStackT m a }
 --   deriving newtype ('Functor', 'Applicative', 'Monad')
 -- @
@@ -464,15 +547,15 @@
 --     'Control.Monad.Trans.Compose.Infix../>' runStateT'
 --     $ unAppT appTma
 --  where
---   runReaderT' :: 'Control.Monad.Reader.Class.MonadReader' 'Bool' m => 'T.ReaderT' 'Char' m a -> m a
+--   runReaderT' :: 'Control.Monad.Reader.Class.MonadReader' 'Bool' m => 'Control.Monad.Trans.Reader.ReaderT' 'Char' m a -> m a
 --   runReaderT' tma = do
 --     bool <- 'Control.Monad.Reader.Class.ask'
 --     let char = if bool then \'Y\' else \'N\'
---     'T.runReaderT' tma char
+--     'Control.Monad.Trans.Reader.runReaderT' tma char
 --
---   runStateT' :: 'Control.Monad.Reader.Class.MonadReader' 'Char' m => 'LT.StateT' 'Int' m a -> m (a, 'Int')
+--   runStateT' :: 'Control.Monad.Reader.Class.MonadReader' 'Char' m => 'Control.Monad.Trans.State.Lazy.StateT' 'Int' m a -> m (a, 'Int')
 --   runStateT' tma = do
 --     char <- 'Control.Monad.Reader.Class.ask'
 --     let num = 'fromEnum' char
---     'LT.runStateT' tma num
+--     'Control.Monad.Trans.State.Lazy.runStateT' tma num
 -- @
diff --git a/src/Control/Monad/Trans/Elevator.hs b/src/Control/Monad/Trans/Elevator.hs
--- a/src/Control/Monad/Trans/Elevator.hs
+++ b/src/Control/Monad/Trans/Elevator.hs
@@ -16,24 +16,30 @@
 import Data.Kind
 
 #if defined(VERSION_exceptions)
-import Control.Monad.Catch
+import Control.Monad.Catch qualified as Exceptions
 #endif
 
 #if defined(VERSION_mtl)
-import Control.Monad.Cont.Class
-import Control.Monad.Error.Class
-import Control.Monad.Reader.Class
-import Control.Monad.RWS.Class (MonadRWS)
-import Control.Monad.State.Class
-import Control.Monad.Writer.Class
+import Control.Monad.Accum qualified as Mtl
+import Control.Monad.Cont.Class qualified as Mtl
+import Control.Monad.Error.Class qualified as Mtl
+import Control.Monad.Reader.Class qualified as Mtl
+import Control.Monad.RWS.Class qualified as Mtl (MonadRWS)
+import Control.Monad.Select qualified as Mtl
+import Control.Monad.State.Class qualified as Mtl
+import Control.Monad.Writer.Class qualified as Mtl
 #endif
 
 #if defined(VERSION_primitive)
-import Control.Monad.Primitive
+import Control.Monad.Primitive qualified as Primitive
 #endif
 
+#if defined(VERSION_resourcet)
+import Control.Monad.Trans.Resource qualified as ResourceT
+#endif
+
 #if defined(VERSION_unliftio_core)
-import Control.Monad.IO.Unlift
+import Control.Monad.IO.Unlift qualified as UnliftIO
 #endif
 
 -- * 'Elevator'
@@ -63,82 +69,94 @@
   deriving newtype (Applicative, Functor, Monad)
   deriving newtype (MonadTrans, MonadTransControl, MonadTransControlIdentity)
 
-instance (Monad (t m), MonadTrans t, MonadBase b m) => MonadBase b (Elevator t m) where
+instance (MonadBase b m, MonadTrans t) => MonadBase b (Elevator t m) where
   liftBase = lift . liftBase
 
-instance (Monad (t m), MonadTransControl t, MonadBaseControl b m) => MonadBaseControl b (Elevator t m) where
+instance (MonadBaseControl b m, MonadTransControl t) => MonadBaseControl b (Elevator t m) where
   type StM (Elevator t m) a = StM m (StT t a)
   liftBaseWith f = liftWith $ \ runT -> liftBaseWith $ \ runInBase -> f $ runInBase . runT
   restoreM = restoreT . restoreM
 
-instance (Monad (t m), MonadTransControlIdentity t, MonadBaseControlIdentity b m) => MonadBaseControlIdentity b (Elevator t m) where
+instance (MonadBaseControlIdentity b m, MonadTransControlIdentity t) => MonadBaseControlIdentity b (Elevator t m) where
   liftBaseWithIdentity = defaultLiftBaseWithIdentity
 
-instance (Monad (t m), MonadTransControl t, Monad m, Alternative m) => Alternative (Elevator t m) where
+instance (Alternative m, Monad m, MonadTransControl t) => Alternative (Elevator t m) where
   empty = lift empty
   (<|>) x y = (restoreT . pure =<<) $ liftWith $ \ runT -> runT x <|> runT y
 
-instance (Monad (t m), MonadTrans t, MonadFail m) => MonadFail (Elevator t m) where
+instance (MonadFail m, MonadTrans t) => MonadFail (Elevator t m) where
   fail = lift . fail
 
-instance (Monad (t m), MonadTransControlIdentity t, MonadFix m) => MonadFix (Elevator t m) where
+instance (MonadFix m, MonadTransControlIdentity t) => MonadFix (Elevator t m) where
   mfix f = liftWithIdentity $ \ runT -> mfix $ \ x -> runT $ f x
 
-instance (Monad (t m), MonadTrans t, MonadIO m) => MonadIO (Elevator t m) where
+instance (MonadIO m, MonadTrans t) => MonadIO (Elevator t m) where
   liftIO = lift . liftIO
 
-instance (Monad (t m), MonadTransControl t, MonadPlus m) => MonadPlus (Elevator t m)
+instance (MonadPlus m, MonadTransControl t) => MonadPlus (Elevator t m)
 
-instance (Monad (t m), MonadTransControlIdentity t, MonadZip m) => MonadZip (Elevator t m) where
+instance (MonadZip m, MonadTransControlIdentity t) => MonadZip (Elevator t m) where
   mzip x y = liftWithIdentity $ \ runT ->
     mzip (runT x) (runT y)
 
 #if defined(VERSION_exceptions)
-instance (Monad (t m), MonadTrans t, MonadThrow m) => MonadThrow (Elevator t m) where
-  throwM = lift . throwM
+instance (Exceptions.MonadThrow m, MonadTrans t) => Exceptions.MonadThrow (Elevator t m) where
+  throwM = lift . Exceptions.throwM
 
-instance (Monad (t m), MonadTransControl t, MonadCatch m) => MonadCatch (Elevator t m) where
+instance (Exceptions.MonadCatch m, MonadTransControl t) => Exceptions.MonadCatch (Elevator t m) where
   catch throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->
-    catch (runT throwing) (runT . catching)
+    Exceptions.catch (runT throwing) (runT . catching)
 #endif
 
 #if defined(VERSION_mtl)
-instance (Monad (t m), MonadTransControl t, MonadCont m) => MonadCont (Elevator t m) where
+instance (Mtl.MonadAccum w m, MonadTrans t) => Mtl.MonadAccum w (Elevator t m) where
+  look = lift Mtl.look
+  add = lift . Mtl.add
+
+instance (Mtl.MonadCont m, MonadTransControl t) => Mtl.MonadCont (Elevator t m) where
   callCC f = (restoreT . pure =<<) $ liftWith $ \ runT ->
-    callCC $ \ c -> runT $ f $ \ a -> restoreT $ c =<< runT (pure a)
+    Mtl.callCC $ \ c -> runT $ f $ \ a -> restoreT $ c =<< runT (pure a)
 
-instance (Monad (t m), MonadTransControl t, MonadError e m) => MonadError e (Elevator t m) where
-  throwError = lift . throwError
+instance (Mtl.MonadError e m, MonadTransControl t) => Mtl.MonadError e (Elevator t m) where
+  throwError = lift . Mtl.throwError
   catchError throwing catching = (restoreT . pure =<<) $ liftWith $ \ runT ->
-    catchError (runT throwing) (runT . catching)
+    Mtl.catchError (runT throwing) (runT . catching)
 
-instance (Monad (t m), MonadTransControl t, MonadReader r m) => MonadReader r (Elevator t m) where
-  ask = lift ask
+instance (Mtl.MonadReader r m, MonadTransControl t) => Mtl.MonadReader r (Elevator t m) where
+  ask = lift Mtl.ask
   local f tma = (restoreT . pure =<<) $ liftWith $ \ runT ->
-    local f $ runT tma
+    Mtl.local f $ runT tma
 
-instance (Monad (t m), MonadTransControl t, MonadRWS r w s m) => MonadRWS r w s (Elevator t m)
+instance (Mtl.MonadRWS r w s m, MonadTransControl t) => Mtl.MonadRWS r w s (Elevator t m)
 
-instance (Monad (t m), MonadTrans t, MonadState s m) => MonadState s (Elevator t m) where
-  get = lift get
-  put = lift . put
+instance (Mtl.MonadSelect r m, MonadTrans t) => Mtl.MonadSelect r (Elevator t m) where
+  select = lift . Mtl.select
 
-instance (Monad (t m), MonadTransControl t, MonadWriter w m) => MonadWriter w (Elevator t m) where
-  tell = lift . tell
-  listen tma = liftWith (\ runT -> listen $ runT tma) >>= \ (sta, w) ->
+instance (Mtl.MonadState s m, MonadTrans t) => Mtl.MonadState s (Elevator t m) where
+  get = lift Mtl.get
+  put = lift . Mtl.put
+
+instance (Mtl.MonadWriter w m, MonadTransControl t) => Mtl.MonadWriter w (Elevator t m) where
+  tell = lift . Mtl.tell
+  listen tma = liftWith (\ runT -> Mtl.listen $ runT tma) >>= \ (sta, w) ->
     (, w) <$> restoreT (pure sta)
-  pass tma = lift . pass . pure =<< tma
+  pass tma = lift . Mtl.pass . pure =<< tma
 #endif
 
 #if defined(VERSION_primitive)
-instance (Monad (t m), MonadTrans t, PrimMonad m) => PrimMonad (Elevator t m) where
-  type PrimState (Elevator t m) = PrimState m
-  primitive = lift . primitive
+instance (Primitive.PrimMonad m, MonadTrans t) => Primitive.PrimMonad (Elevator t m) where
+  type PrimState (Elevator t m) = Primitive.PrimState m
+  primitive = lift . Primitive.primitive
 #endif
 
+#if defined(VERSION_resourcet)
+instance (ResourceT.MonadResource m, MonadTrans t) => ResourceT.MonadResource (Elevator t m) where
+  liftResourceT = lift . ResourceT.liftResourceT
+#endif
+
 #if defined(VERSION_unliftio_core)
-instance (Monad (t m), MonadTransControlIdentity t, MonadUnliftIO m) => MonadUnliftIO (Elevator t m) where
-  withRunInIO f = liftWithIdentity $ \runT -> withRunInIO $ \runInIO -> f $ runInIO . runT
+instance (UnliftIO.MonadUnliftIO m, MonadTransControlIdentity t) => UnliftIO.MonadUnliftIO (Elevator t m) where
+  withRunInIO f = liftWithIdentity $ \runT -> UnliftIO.withRunInIO $ \runInIO -> f $ runInIO . runT
 #endif
 
 -- * Examples