diff --git a/Control/Monad/CatchIO.hs b/Control/Monad/CatchIO.hs
--- a/Control/Monad/CatchIO.hs
+++ b/Control/Monad/CatchIO.hs
@@ -2,107 +2,11 @@
                                E.Exception(..),
                                throw,
                                try, tryJust,
-                               onException, bracket,
+                               onException, bracket, bracket_,
+                               finally, bracketOnError,
                                Handler(..), catches )
 
 where
 
-import Prelude hiding ( catch )
-
+import "MonadCatchIO-transformers" Control.Monad.CatchIO
 import qualified Control.Exception.Extensible as E
-
-import Control.Monad.Reader
-import Control.Monad.State
-import Control.Monad.Error
-import Control.Monad.Writer
-import Control.Monad.RWS
-
-class MonadIO m => MonadCatchIO m where
-    -- | Generalized version of 'E.catch'
-    catch   :: E.Exception e => m a -> (e -> m a) -> m a
- 
-    -- | Generalized version of 'E.block'
-    block   :: m a -> m a
-
-    -- | Generalized version of 'E.unblock'
-    unblock :: m a -> m a
-
--- | Generalized version of 'E.throwIO'
-throw :: (MonadCatchIO m, E.Exception e) => e -> m a
-
--- | Generalized version of 'E.try'
-try :: (MonadCatchIO m, E.Exception e) => m a -> m (Either e a)
-
--- | Generalized version of 'E.tryJust'
-tryJust :: (MonadCatchIO m, E.Exception e)
-        => (e -> Maybe b) -> m a -> m (Either b a)
-
--- | Generalized version of 'E.Handler'
-data Handler m a = forall e . E.Exception e => Handler (e -> m a)
-
--- | Generalized version of 'E.catches'
-catches :: MonadCatchIO m => m a -> [Handler m a] -> m a
-catches a handlers = a `catch` handler
-    where handler e = foldr tryH (throw e) handlers
-            where tryH (Handler h) res = case E.fromException e of
-                                             Just e' -> h e'
-                                             Nothing -> res
-
-
-instance MonadCatchIO IO where
-    catch   = E.catch
-    block   = E.block
-    unblock = E.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
-    unblock     = mapReaderT unblock
-
-instance MonadCatchIO m => MonadCatchIO (StateT s m) where
-    m `catch` f = StateT $ \s -> (runStateT m s)
-                                   `catch` (\e -> runStateT (f e) s)
-    block       = mapStateT block
-    unblock     = 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 (Monoid w, MonadCatchIO m) => MonadCatchIO (WriterT w m) where
-    m `catch` f = WriterT $ runWriterT m
-                              `catch` \e -> runWriterT (f e)
-    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
-
-throw = liftIO . E.throwIO
-
-try a = catch (a >>= \ v -> return (Right v)) (\e -> return (Left e))
-
-tryJust p a = do
-  r <- try a
-  case r of
-        Right v -> return (Right v)
-        Left  e -> case p e of
-                        Nothing -> throw e `asTypeOf` (return $ Left undefined)
-                        Just b  -> return (Left b)
-
--- | Generalized version of 'E.bracket'
-bracket :: MonadCatchIO m => m a -> (a -> m b) -> (a -> m c) -> m c
-bracket before after thing =
-    block (do a <- before
-              r <- unblock (thing a) `onException` after a
-              after a
-              return r)
-
--- | Generalized version of 'E.onException'
-onException :: MonadCatchIO m => m a -> m b -> m a
-onException a onEx = a `catch` (\(e::E.SomeException) -> onEx >> throw e)
diff --git a/LICENSE b/LICENSE
new file mode 100644
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,30 @@
+Copyright 2004-2008, Oleg Kiselyov, Alistair Bayley (from Takusen)
+          2008-2011, Daniel Gorin  
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+ * Redistributions of source code must retain the above copyright notice,
+   this list of conditions and the following disclaimer.
+
+ * Redistributions in binary form must reproduce the above copyright
+   notice, this list of conditions and the following disclaimer in the
+   documentation and/or other materials provided with the distribution.
+
+ * Neither the name of the copyright holder(s) nor the names of
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/MonadCatchIO-mtl.cabal b/MonadCatchIO-mtl.cabal
--- a/MonadCatchIO-mtl.cabal
+++ b/MonadCatchIO-mtl.cabal
@@ -1,5 +1,5 @@
 name:                MonadCatchIO-mtl
-version:             0.2.0.0
+version:             0.3.1.0
 description:
         Provides a monad-transformer version of the @Control.Exception.catch@
         function. For this, it defines the @MonadCatchIO@ class, a subset of
@@ -8,18 +8,17 @@
 
 synopsis:           Monad-transformer version of the Control.Exception module
 category:           Control
-license:            PublicDomain
+license:            BSD3
+license-file:       LICENSE
 maintainer:         jcpetruzza@gmail.com
-homepage:           http://code.haskell.org/~jcpetruzza/MonadCatchIO-mtl
+homepage:           http://darcsden.com/jcpetruzza/MonadCatchIO-mtl
 
-cabal-version:      >= 1.2
+cabal-version:      >= 1.4
 build-type:         Simple
-tested-with:        GHC==6.10
+tested-with:        GHC==6.12.3, GHC==7.0.3, GHC==7.2.1, GHC==7.4.2, GHC==7.6.0
 
 Library
-  build-depends:    base, mtl, extensible-exceptions
-  ghc-options:      -Wall
-  extensions:       ExistentialQuantification,
-                    ScopedTypeVariables
+  build-depends:    base < 5, extensible-exceptions, MonadCatchIO-transformers==0.3.1.0
+  extensions:       PackageImports
 
   exposed-modules: Control.Monad.CatchIO