diff --git a/MonadCatchIO-transformers.cabal b/MonadCatchIO-transformers.cabal
--- a/MonadCatchIO-transformers.cabal
+++ b/MonadCatchIO-transformers.cabal
@@ -1,5 +1,5 @@
 Name:            MonadCatchIO-transformers
-Version:         0.2.1.0
+Version:         0.2.2.0
 Cabal-Version:   >= 1.6
 License:         PublicDomain
 Description:
@@ -13,6 +13,10 @@
 Synopsis:        Monad-transformer compatible version of the Control.Exception module
 Build-Type:      Simple
 
+Source-repository head
+  Type:     darcs
+  Location: http://patch-tag.com/r/AriePeterson/MonadCatchIO-transformers
+
 Library
   Build-Depends:
     base == 4.*,
@@ -21,8 +25,4 @@
   Exposed-Modules:
     Control.Monad.CatchIO
   Hs-Source-Dirs:  src
-  Ghc-options: -Wall
-  Extensions:
-    ExistentialQuantification,
-    ScopedTypeVariables
-
+  Ghc-options:     -Wall
diff --git a/src/Control/Monad/CatchIO.hs b/src/Control/Monad/CatchIO.hs
--- a/src/Control/Monad/CatchIO.hs
+++ b/src/Control/Monad/CatchIO.hs
@@ -1,3 +1,4 @@
+{-# LANGUAGE ExistentialQuantification, ScopedTypeVariables #-}
 module Control.Monad.CatchIO
   (
     MonadCatchIO(..)
@@ -16,20 +17,27 @@
 where
 
 import           Prelude hiding ( catch )
+import           Control.Applicative                          ((<$>))
+import qualified Control.Exception.Extensible      as E
 
-import           Control.Applicative        ((<$>))
-import qualified Control.Exception.Extensible as E
+import           Control.Monad.IO.Class                       (MonadIO,liftIO)
 
-import           Control.Monad.IO.Class           (MonadIO,liftIO)  
-import           Control.Monad.Trans.Error        (ErrorT          ,runErrorT ,mapErrorT ,Error)
-import           Control.Monad.Trans.Reader       (ReaderT(ReaderT),runReaderT,mapReaderT)
-import           Control.Monad.Trans.State        (StateT(StateT)  ,runStateT ,mapStateT )
-import qualified Control.Monad.Trans.State.Strict as StrictState
-import           Control.Monad.Trans.Writer       (WriterT(WriterT),runWriterT,mapWriterT)
-import           Control.Monad.Trans.RWS          (RWST(RWST)      ,runRWST   ,mapRWST   )
-import           Data.Monoid                      (Monoid)
+import           Control.Monad.Trans.Cont                     (ContT(ContT)    ,runContT    ,mapContT    )
+import           Control.Monad.Trans.Error                    (ErrorT          ,runErrorT   ,mapErrorT   ,Error)
+import           Control.Monad.Trans.Identity                 (IdentityT       ,runIdentityT,mapIdentityT)
+import           Control.Monad.Trans.List                     (ListT(ListT)    ,runListT    ,mapListT    )
+import           Control.Monad.Trans.Maybe                    (MaybeT          ,runMaybeT   ,mapMaybeT   )
+import           Control.Monad.Trans.RWS                      (RWST(RWST)      ,runRWST     ,mapRWST     )
+import qualified Control.Monad.Trans.RWS.Strict    as Strict  (RWST(RWST)      ,runRWST     ,mapRWST     )
+import           Control.Monad.Trans.Reader                   (ReaderT(ReaderT),runReaderT  ,mapReaderT  )
+import           Control.Monad.Trans.State                    (StateT(StateT)  ,runStateT   ,mapStateT   )
+import qualified Control.Monad.Trans.State.Strict  as Strict  (StateT(StateT)  ,runStateT   ,mapStateT   )
+import           Control.Monad.Trans.Writer                   (WriterT         ,runWriterT  ,mapWriterT  )
+import qualified Control.Monad.Trans.Writer.Strict as Strict  (WriterT         ,runWriterT  ,mapWriterT  )
 
+import           Data.Monoid                                  (Monoid)
 
+
 class MonadIO m => MonadCatchIO m where
   -- | Generalized version of 'E.catch'
   catch   :: E.Exception e => m a -> (e -> m a) -> m a
@@ -46,6 +54,41 @@
   block   = E.block
   unblock = E.unblock
 
+instance MonadCatchIO m => MonadCatchIO (ContT r m) where
+  m `catch` f = ContT $ \c -> runContT m c `catch` \e -> runContT (f e) c
+  block       = mapContT block
+  unblock     = mapContT unblock
+
+instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m) where
+  m `catch` f = mapErrorT (\m' -> m' `catch` \e -> runErrorT $ f e) m
+  block       = mapErrorT block
+  unblock     = mapErrorT unblock
+
+instance (MonadCatchIO m) => MonadCatchIO (IdentityT m) where
+  m `catch` f = mapIdentityT (\m' -> m' `catch` \e -> runIdentityT $ f e) m
+  block       = mapIdentityT block
+  unblock     = mapIdentityT unblock
+
+instance MonadCatchIO m => MonadCatchIO (ListT m) where
+  m `catch` f = ListT $ runListT m `catch` \e -> runListT (f e)
+  block       = mapListT block
+  unblock     = mapListT unblock
+
+instance (MonadCatchIO m) => MonadCatchIO (MaybeT m) where
+  m `catch` f = mapMaybeT (\m' -> m' `catch` \e -> runMaybeT $ f e) m
+  block       = mapMaybeT block
+  unblock     = mapMaybeT unblock
+
+instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m) where
+  m `catch` f = RWST $ \r s -> runRWST m r s `catch` \e -> runRWST (f e) r s
+  block       = mapRWST block
+  unblock     = mapRWST unblock
+
+instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.RWST r w s m) where
+  m `catch` f = Strict.RWST $ \r s -> Strict.runRWST m r s `catch` \e -> Strict.runRWST (f e) r s
+  block       = Strict.mapRWST block
+  unblock     = Strict.mapRWST unblock
+
 instance MonadCatchIO m => MonadCatchIO (ReaderT r m) where
   m `catch` f = ReaderT $ \r -> runReaderT m r `catch` \e -> runReaderT (f e) r
   block       = mapReaderT block
@@ -56,26 +99,20 @@
   block       = mapStateT block
   unblock     = mapStateT unblock
 
-instance MonadCatchIO m => MonadCatchIO (StrictState.StateT s m) where
-  m `catch` f = StrictState.StateT $ \s -> StrictState.runStateT m s `catch` \e -> StrictState.runStateT (f e) s
-  block       = StrictState.mapStateT block
-  unblock     = StrictState.mapStateT unblock
-
-instance (MonadCatchIO m, Error e) => MonadCatchIO (ErrorT e m) where
-  m `catch` f = mapErrorT (\m' -> m' `catch` \e -> runErrorT $ f e) m
-  block       = mapErrorT block
-  unblock     = mapErrorT unblock
+instance MonadCatchIO m => MonadCatchIO (Strict.StateT s m) where
+  m `catch` f = Strict.StateT $ \s -> Strict.runStateT m s `catch` \e -> Strict.runStateT (f e) s
+  block       = Strict.mapStateT block
+  unblock     = Strict.mapStateT unblock
 
 instance (Monoid w, MonadCatchIO m) => MonadCatchIO (WriterT w m) where
-  m `catch` f = WriterT $ runWriterT m `catch` \e -> runWriterT $ f e
+  m `catch` f = mapWriterT (\m' -> m' `catch` \e -> runWriterT $ f e) m
   block       = mapWriterT block
   unblock     = mapWriterT unblock
 
-instance (Monoid w, MonadCatchIO m) => MonadCatchIO (RWST r w s m) where
-  m `catch` f = RWST $ \r s -> runRWST m r s `catch` \e -> runRWST (f e) r s
-  block       = mapRWST block
-  unblock     = mapRWST unblock
-
+instance (Monoid w, MonadCatchIO m) => MonadCatchIO (Strict.WriterT w m) where
+  m `catch` f = Strict.mapWriterT (\m' -> m' `catch` \e -> Strict.runWriterT $ f e) m
+  block       = Strict.mapWriterT block
+  unblock     = Strict.mapWriterT unblock
 
 -- | Generalized version of 'E.throwIO'
 throw :: (MonadIO m, E.Exception e) => e -> m a
@@ -110,7 +147,7 @@
 bracket before after thing = block $ do
   a <- before
   r <- unblock (thing a) `onException` after a
-  after a
+  _ <- after a
   return r
 
 -- | Generalized version of 'E.onException'
@@ -125,9 +162,9 @@
          -> m c  -- ^ computation to run in-between
          -> m c  -- returns the value from the in-between computation
 bracket_ before after thing = block $ do
-  before
+  _ <- before
   r <- unblock thing `onException` after
-  after
+  _ <- after
   return r
 
 -- | A specialised variant of 'bracket' with just a computation to run
@@ -139,7 +176,7 @@
         -> m a -- returns the value from the first computation
 thing `finally` after = block $ do
   r <- unblock thing `onException` after
-  after
+  _ <- after
   return r
 
 -- | Like 'bracket', but only performs the final action if there was an