diff --git a/Control/Monad/Failure.hs b/Control/Monad/Failure.hs
--- a/Control/Monad/Failure.hs
+++ b/Control/Monad/Failure.hs
@@ -1,3 +1,4 @@
-module Control.Monad.Failure (module Control.Monad.Failure.Class) where
+module Control.Monad.Failure (module Control.Failure) where
 
-import Control.Monad.Failure.Class
+import Control.Failure
+
diff --git a/Control/Monad/Failure/Class.hs b/Control/Monad/Failure/Class.hs
deleted file mode 100644
--- a/Control/Monad/Failure/Class.hs
+++ /dev/null
@@ -1,39 +0,0 @@
-{-# LANGUAGE Rank2Types #-}
-{-# LANGUAGE DeriveDataTypeable #-}
-{-# LANGUAGE FlexibleContexts #-}
-{-| Defines the class @MonadFailure@ for monads which can fail.
--}
-module Control.Monad.Failure.Class where
-
-import Control.Exception (throw, Exception)
-import Data.Typeable
-
-class Monad m => MonadFailure e m where
-    failure :: e -> m a
-
-class MonadFailure e m => WrapFailure e m where
-    -- | Wrap the failure value, if any, with the given function. This is
-    -- useful in particular when you want all the exceptions returned from a
-    -- certain library to be of a certain type, even if they were generated by
-    -- a different library.
-    wrapFailure :: (forall eIn. Exception eIn => eIn -> e) -> m a -> m a
-
--- --------------
--- base instances
--- --------------
-
-instance MonadFailure e Maybe where failure _ = Nothing
-instance MonadFailure e []    where failure _ = []
-
-instance Exception e => MonadFailure e IO where
-  failure = Control.Exception.throw
-
--- | Call 'failure' with a 'String'.
-failureString :: MonadFailure StringException m => String -> m a
-failureString = failure . StringException
-
-newtype StringException = StringException String
-    deriving Typeable
-instance Show StringException where
-    show (StringException s) = "StringException: " ++ s
-instance Exception StringException
diff --git a/Control/Monad/Failure/MTL.hs b/Control/Monad/Failure/MTL.hs
--- a/Control/Monad/Failure/MTL.hs
+++ b/Control/Monad/Failure/MTL.hs
@@ -3,9 +3,9 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# OPTIONS_GHC -fno-warn-orphans #-}
 
-module Control.Monad.Failure.MTL (module Control.Monad.Failure.Class) where
+module Control.Monad.Failure.MTL (module Control.Failure) where
 
-import Control.Monad.Failure.Class
+import Control.Failure hiding (Error)
 
 import Control.Monad.Error
 import Control.Monad.List
@@ -22,59 +22,56 @@
 -- MonadFailure Instances
 -- -----------------------
 
-instance (Error e) => MonadFailure e (Either e) where
-  failure = Left
-
-instance (Error e, Monad m) => MonadFailure e (ErrorT e m) where
+instance (Error e, Monad m) => Failure e (ErrorT e m) where
   failure = throwError
 
-instance MonadFailure e m => MonadFailure e (ListT m) where
+instance (Monad m, Failure e m) => Failure e (ListT m) where
   failure = lift . failure
 
-instance MonadFailure e m => MonadFailure e (ReaderT r m) where
+instance (Monad m, Failure e m) => Failure e (ReaderT r m) where
   failure = lift . failure
 
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.WriterT w  m) where
+instance (Monoid w, Monad m, Failure e m) => Failure e (Lazy.WriterT w  m) where
   failure = lift . failure
 
-instance MonadFailure e m => MonadFailure e (Lazy.StateT s m) where
+instance (Monad m, Failure e m) => Failure e (Lazy.StateT s m) where
   failure = lift . failure
 
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.RWST r w s m) where
+instance (Monoid w, Monad m, Failure e m) => Failure e (Lazy.RWST r w s m) where
   failure = lift . failure
 
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.WriterT w  m) where
+instance (Monoid w, Monad m, Failure e m) => Failure e (Strict.WriterT w  m) where
   failure = lift . failure
 
-instance MonadFailure e m => MonadFailure e (Strict.StateT s m) where
+instance (Monad m, Failure e m) => Failure e (Strict.StateT s m) where
   failure = lift . failure
 
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.RWST r w s m) where
+instance (Monoid w, Monad m, Failure e m) => Failure e (Strict.RWST r w s m) where
   failure = lift . failure
 
 -- ---------------------
 -- WrapFailure instances
 -- ---------------------
 
-instance WrapFailure e m => WrapFailure e (ListT m) where
+instance (WrapFailure e m, Monad m) => WrapFailure e (ListT m) where
   wrapFailure f = ListT . wrapFailure f . runListT
 
-instance WrapFailure e m => WrapFailure e (ReaderT r m) where
+instance (WrapFailure e m, Monad m) => WrapFailure e (ReaderT r m) where
   wrapFailure f m = ReaderT $ \r -> wrapFailure f (runReaderT m r)
 
-instance (WrapFailure e m, Monoid w) => WrapFailure e (Lazy.WriterT w m) where
+instance (WrapFailure e m, Monoid w, Monad m) => WrapFailure e (Lazy.WriterT w m) where
   wrapFailure f = Lazy.WriterT . wrapFailure f . Lazy.runWriterT
 
 
 -- all the following instances require undecidable instances
-instance WrapFailure e m => WrapFailure e (Lazy.StateT s m) where
+instance (WrapFailure e m, Monad m) => WrapFailure e (Lazy.StateT s m) where
   wrapFailure f m = Lazy.StateT $ \s -> wrapFailure f (Lazy.runStateT m s)
 
-instance (WrapFailure e m, Monoid w) => WrapFailure e (Lazy.RWST r w s m) where
+instance (WrapFailure e m, Monoid w, Monad m) => WrapFailure e (Lazy.RWST r w s m) where
   wrapFailure f m = Lazy.RWST $ \r s -> wrapFailure f (Lazy.runRWST m r s)
 
-instance WrapFailure e m => WrapFailure e (Strict.StateT s m) where
+instance (WrapFailure e m, Monad m) => WrapFailure e (Strict.StateT s m) where
   wrapFailure f m = Strict.StateT $ \s -> wrapFailure f (Strict.runStateT m s)
 
-instance (WrapFailure e m, Monoid w) => WrapFailure e (Strict.RWST r w s m) where
+instance (WrapFailure e m, Monoid w, Monad m) => WrapFailure e (Strict.RWST r w s m) where
   wrapFailure f m = Strict.RWST $ \r s -> wrapFailure f (Strict.runRWST m r s)
diff --git a/Setup.hs b/Setup.hs
deleted file mode 100644
--- a/Setup.hs
+++ /dev/null
@@ -1,2 +0,0 @@
-import Distribution.Simple
-main = defaultMain
diff --git a/Setup.lhs b/Setup.lhs
new file mode 100644
--- /dev/null
+++ b/Setup.lhs
@@ -0,0 +1,7 @@
+#!/usr/bin/env runhaskell
+
+> module Main where
+> import Distribution.Simple
+
+> main :: IO ()
+> main = defaultMain
diff --git a/control-monad-failure-mtl.cabal b/control-monad-failure-mtl.cabal
--- a/control-monad-failure-mtl.cabal
+++ b/control-monad-failure-mtl.cabal
@@ -1,5 +1,5 @@
 name: control-monad-failure-mtl
-version: 0.5.0
+version: 0.6.0
 Cabal-Version:  >= 1.6
 build-type: Simple
 license: PublicDomain
@@ -8,17 +8,18 @@
 homepage: http://github.com/pepeiborra/control-monad-failure
 description: A class for monads which can fail with an error.
 synopsis: A class for monads which can fail with an error.
-category: Control, Monads
+category: Control, Monads, Failure
 stability: experimental
 
 Library
   buildable: True
-  build-depends: base >= 4 && < 5, mtl
+  build-depends: base >= 4 && < 5,
+                 failure >= 0.0.0 && < 0.1,
+                 mtl >= 1.1.0.2 && < 1.2
   ghc-options: -Wall
   extensions:  MultiParamTypeClasses, FlexibleInstances
   exposed-modules:
      Control.Monad.Failure
-     Control.Monad.Failure.Class
      Control.Monad.Failure.MTL
 
 source-repository head