diff --git a/MonadLib/Compose.hs b/MonadLib/Compose.hs
--- a/MonadLib/Compose.hs
+++ b/MonadLib/Compose.hs
@@ -28,6 +28,8 @@
 , ComposeM(..)
 , (<<<)
 , (>>>)
+, derive_mcompose
+, derive_mapply
 )
 where
   
@@ -46,6 +48,11 @@
     -- | Compose two monadic values from right to left. @mcompose f g@ is 
     -- comparable to @f . g@ but for monadic values. Compare with 'Control.Category..'.
     mcompose :: m a -> n s -> n a
+    mcompose m n = mapply m =<< n
+    
+    -- | Apply a constant value to a composable monad.
+    mapply :: m a -> s -> n a
+    mapply m s = mcompose m (return s)
 
 -- | Compose two monadic values from right to left. Compare with 'Control.Category.<<<'.
 -- @f <<< g@ is equivalent to @mcompose f g@.
@@ -59,43 +66,44 @@
 (>>>) = flip mcompose
 infixl 1 >>>
 
+derive_mcompose :: ComposeM m n s t => Iso m o -> Iso n p -> o a -> p s -> p a
+derive_mcompose (Iso _ openM) (Iso closeN openN) m n = closeN $ mcompose (openM m) (openN n)
+
+derive_mapply :: ComposeM m n s t => Iso m o -> Iso n p -> o a -> s -> p a
+derive_mapply (Iso _ openM) (Iso closeN _) m s = closeN $ mapply (openM m) s
+
 instance ComposeM ((->) s) ((->) t) s t where
     mcompose = (.)
 
 instance Monad m => ComposeM (ReaderT s m) (ReaderT t m) s t where
-    mcompose m n = do
-      s <- n
-      lift (runReaderT s m)
+    mapply m s = lift (runReaderT s m)
 
 instance ComposeM (Reader s) (Reader t) s t where
     mcompose m n = asks $ flip runReader m . flip runReader n
 
-derive_mcompose close open m n = do
-  s <- n
-  u <- lift $ mcompose (open m) (return s)
-  close u
+x_mapply :: (MonadT xt, ComposeM m n s t, Monad (xt n)) 
+            => (a -> xt n b) -> (xt m c -> m a) -> xt m c -> s -> xt n b
+x_mapply close open m s = lift (open m `mapply` s) >>= close
 
 instance ComposeM m n s t => ComposeM (IdT m) (IdT n) s t where
-    mcompose = derive_mcompose return runIdT
+    mapply = x_mapply return runIdT
 
 instance (ComposeM m n s t, Monoid w) => ComposeM (WriterT w m) (WriterT w n) s t where
-    mcompose = derive_mcompose puts runWriterT
+    mapply = x_mapply puts runWriterT
 
 instance ComposeM m n s t => ComposeM (ExceptionT e m) (ExceptionT e n) s t where
-    mcompose = derive_mcompose raises runExceptionT
+    mapply = x_mapply raises runExceptionT
 
 instance ComposeM m n s t => ComposeM (StateT i m) (StateT i n) s t where
-    mcompose m n = do
-      s <- n
+    mapply m s = do
       i <- get
-      (u, i') <- lift $ mcompose (runStateT i m) (return s)
+      (u, i') <- lift $ mapply (runStateT i m) s
       set i'
       return u
 
 instance ComposeM m n s t => ComposeM (ChoiceT m) (ChoiceT n) s t where
-    mcompose m n = do
-      s <- n
-      u <- lift $ mcompose (runChoiceT m) (return s)
+    mapply m s = do
+      u <- lift $ mapply (runChoiceT m) s
       case u of
         Nothing -> mzero
-        Just (a, m') -> return a `mplus` (mcompose m' (return s))
+        Just (a, m') -> return a `mplus` (mapply m' s)
diff --git a/monadLib-compose.cabal b/monadLib-compose.cabal
--- a/monadLib-compose.cabal
+++ b/monadLib-compose.cabal
@@ -7,7 +7,7 @@
 -- The package version. See the Haskell package versioning policy
 -- (http://www.haskell.org/haskellwiki/Package_versioning_policy) for
 -- standards guiding when and how versions should be incremented.
-Version:             0.1.1
+Version:             0.2
 
 -- A short (one-line) description of the package.
 Synopsis:            Arrow-like monad composition for monadLib.