diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,5 +1,12 @@
 # Revision history for deriving-trans
 
+## 0.4.0.0 *18 Jul 2022*
+
+* Add dependency on monad-control-identity.
+* Add instances for `MonadTransControlIdentity` and `MonadBaseControlIdentity`.
+* Add `MonadZip` instance to `Elevator`.
+* Constrain the `MonadFix` instance for `Elevator` with `MonadTransControlIdentity`.
+
 ## 0.3.2.0 *31 Mar 2022*
 
 * Remove version boundaries of dependencies.
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.3.2.0
+version:             0.4.0.0
 synopsis:            Derive instances for monad transformer stacks
 description:         Implementing instances for monad transformer stacks can be tedious.
                      <https://hackage.haskell.org/package/mtl mtl> defines each instance for each
@@ -32,6 +32,7 @@
   build-depends:
     , base < 5
     , monad-control
+    , monad-control-identity
     , mtl
     , transformers
     , transformers-base
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
@@ -11,6 +11,7 @@
 import Control.Monad.State.Class
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Control
+import Control.Monad.Trans.Control.Identity
 import Control.Monad.Trans.Elevator
 import qualified Control.Monad.Trans.Cont as T
 import qualified Control.Monad.Trans.Except as T
@@ -59,6 +60,10 @@
   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
+  liftWithIdentity inner = ComposeT $ liftWithIdentity $ \ runId1 ->
+    liftWithIdentity $ \ runId2 -> inner $ runId2 . runId1 . deComposeT
+
 -- | Elevated to @m@.
 deriving via Elevator (ComposeT t1 t2) m
   instance
@@ -83,9 +88,17 @@
     , MonadBaseControl b m
     ) => MonadBaseControl b (ComposeT t1 t2 m)
 
+-- | Elevated to @m@.
+deriving via Elevator (ComposeT t1 t2) m
+  instance
+    ( Monad (t1 (t2 m))
+    , MonadTransControlIdentity (ComposeT t1 t2)
+    , MonadBaseControlIdentity b m
+    ) => MonadBaseControlIdentity b (ComposeT t1 t2 m)
+
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTransControl t1
@@ -93,14 +106,14 @@
     ) => MonadCont (ComposeT t1 t2 m)
 
 -- | Set by 'T.ContT'.
-deriving via T.ContT r (t2 (m :: * -> *))
+deriving via T.ContT r (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     ) => MonadCont (ComposeT (T.ContT r) t2 m)
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTransControl t1
@@ -108,14 +121,14 @@
     ) => MonadError e (ComposeT t1 t2 m)
 
 -- | Set by 'T.ExceptT'.
-deriving via T.ExceptT e (t2 (m :: * -> *))
+deriving via T.ExceptT e (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     ) => MonadError e (ComposeT (T.ExceptT e) t2 m)
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTransControl t1
@@ -123,20 +136,20 @@
     ) => MonadReader r (ComposeT t1 t2 m)
 
 -- | Set by 'T.ReaderT'.
-deriving via T.ReaderT r (t2 (m :: * -> *))
+deriving via T.ReaderT r (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     ) => MonadReader r (ComposeT (T.ReaderT r) t2 m)
 
 -- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: * -> *))
+deriving via LT.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
     ) => MonadReader r (ComposeT (LT.RWST r w s) t2 m)
 
 -- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: * -> *))
+deriving via ST.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
@@ -144,7 +157,7 @@
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTransControl t1
@@ -152,14 +165,14 @@
     ) => MonadRWS r w s (ComposeT t1 t2 m)
 
 -- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: * -> *))
+deriving via LT.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)
 
 -- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: * -> *))
+deriving via ST.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
@@ -167,7 +180,7 @@
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTrans t1
@@ -175,26 +188,26 @@
     ) => MonadState s (ComposeT t1 t2 m)
 
 -- | Set by 'LT.StateT'.
-deriving via LT.StateT s (t2 (m :: * -> *))
+deriving via LT.StateT s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     ) => MonadState s (ComposeT (LT.StateT s) t2 m)
 
 -- | Set by 'ST.StateT'.
-deriving via ST.StateT s (t2 (m :: * -> *))
+deriving via ST.StateT s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     ) => MonadState s (ComposeT (ST.StateT s) t2 m)
 
 -- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: * -> *))
+deriving via LT.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
     ) => MonadState s (ComposeT (LT.RWST r w s) t2 m)
 
 -- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: * -> *))
+deriving via ST.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
@@ -202,7 +215,7 @@
 
 -- | /OVERLAPPABLE/.
 -- Elevated to @(t2 m)@.
-deriving via Elevator t1 (t2 (m :: * -> *))
+deriving via Elevator t1 (t2 (m :: Type -> Type))
   instance {-# OVERLAPPABLE #-}
     ( Monad (t1 (t2 m))
     , MonadTransControl t1
@@ -210,28 +223,28 @@
     ) => MonadWriter w (ComposeT t1 t2 m)
 
 -- | Set by 'LT.WriterT'.
-deriving via LT.WriterT w (t2 (m :: * -> *))
+deriving via LT.WriterT w (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
     ) => MonadWriter w (ComposeT (LT.WriterT w) t2 m)
 
 -- | Set by 'ST.WriterT'.
-deriving via ST.WriterT w (t2 (m :: * -> *))
+deriving via ST.WriterT w (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
     ) => MonadWriter w (ComposeT (ST.WriterT w) t2 m)
 
 -- | Set by 'LT.RWST'.
-deriving via LT.RWST r w s (t2 (m :: * -> *))
+deriving via LT.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
     ) => MonadWriter w (ComposeT (LT.RWST r w s) t2 m)
 
 -- | Set by 'ST.RWST'.
-deriving via ST.RWST r w s (t2 (m :: * -> *))
+deriving via ST.RWST r w s (t2 (m :: Type -> Type))
   instance
     ( Monad (t2 m)
     , Monoid w
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
@@ -13,7 +13,9 @@
 import Control.Monad.State.Class
 import Control.Monad.Trans
 import Control.Monad.Trans.Control
+import Control.Monad.Trans.Control.Identity
 import Control.Monad.Writer.Class
+import Control.Monad.Zip
 import Data.Kind
 
 -- * 'Elevator'
@@ -39,7 +41,7 @@
               -> Type
 newtype Elevator t m a = Ascend { descend :: t m a }
   deriving newtype (Applicative, Functor, Monad)
-  deriving newtype (MonadTrans, MonadTransControl)
+  deriving newtype (MonadTrans, MonadTransControl, MonadTransControlIdentity)
 
 instance (Monad (t m), MonadTrans t, MonadBase b m) => MonadBase b (Elevator t m) where
   liftBase = lift . liftBase
@@ -49,6 +51,9 @@
   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
+  liftBaseWithIdentity = defaultLiftBaseWithIdentity
+
 instance (Monad (t m), MonadTransControl t, Monad m, Alternative m) => Alternative (Elevator t m) where
   empty = lift empty
   (<|>) x y = (restoreT . pure =<<) $ liftWith $ \ runT -> runT x <|> runT y
@@ -56,14 +61,17 @@
 instance (Monad (t m), MonadTrans t, MonadFail m) => MonadFail (Elevator t m) where
   fail = lift . fail
 
-instance (Monad (t m), MonadTransControl t, MonadFix m) => MonadFix (Elevator t m) where
-  mfix f = (restoreT . pure =<<) $ liftWith $ \ runT ->
-    mfix $ \ x -> runT $ (f =<<) $ restoreT $ pure x
+instance (Monad (t m), MonadTransControlIdentity t, MonadFix m) => 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
   liftIO = lift . liftIO
 
 instance (Monad (t m), MonadTransControl t, MonadPlus m) => MonadPlus (Elevator t m)
+
+instance (Monad (t m), MonadTransControlIdentity t, MonadZip m) => MonadZip (Elevator t m) where
+  mzip x y = liftWithIdentity $ \ runT ->
+    mzip (runT x) (runT y)
 
 instance (Monad (t m), MonadTransControl t, MonadCont m) => MonadCont (Elevator t m) where
   callCC f = (restoreT . pure =<<) $ liftWith $ \ runT ->