diff --git a/Control/Monad/Failure/Class.hs b/Control/Monad/Failure/Class.hs
--- a/Control/Monad/Failure/Class.hs
+++ b/Control/Monad/Failure/Class.hs
@@ -1,9 +1,12 @@
 {-# 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
@@ -24,3 +27,13 @@
 
 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
new file mode 100644
--- /dev/null
+++ b/Control/Monad/Failure/MTL.hs
@@ -0,0 +1,76 @@
+{-# LANGUAGE MultiParamTypeClasses #-}
+{-# LANGUAGE UndecidableInstances #-}
+{-# LANGUAGE FlexibleInstances #-}
+
+module Control.Monad.Failure.MTL (module Control.Monad.Failure.Class) where
+
+import Control.Monad.Failure.Class
+
+import Control.Monad.Error
+import Control.Monad.List
+import Control.Monad.Reader
+import Control.Monad.State.Lazy     as Lazy
+import Control.Monad.State.Strict   as Strict
+import Control.Monad.Writer.Lazy    as Lazy
+import Control.Monad.Writer.Strict  as Strict
+import Control.Monad.RWS.Lazy       as Lazy
+import Control.Monad.RWS.Strict     as Strict
+import Data.Monoid
+
+-- -----------------------
+-- MonadFailure Instances
+-- -----------------------
+
+instance (Error e, Monad m) => MonadFailure e (ErrorT e m) where
+  failure = throwError
+
+instance MonadFailure e m => MonadFailure e (ListT m) where
+  failure = lift . failure
+
+instance MonadFailure e m => MonadFailure e (ReaderT r m) where
+  failure = lift . failure
+
+instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.WriterT w  m) where
+  failure = lift . failure
+
+instance MonadFailure e m => MonadFailure e (Lazy.StateT s m) where
+  failure = lift . failure
+
+instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.RWST r w s m) where
+  failure = lift . failure
+
+instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.WriterT w  m) where
+  failure = lift . failure
+
+instance MonadFailure e m => MonadFailure e (Strict.StateT s m) where
+  failure = lift . failure
+
+instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.RWST r w s m) where
+  failure = lift . failure
+
+-- ---------------------
+-- WrapFailure instances
+-- ---------------------
+
+instance WrapFailure e m => WrapFailure e (ListT m) where
+  wrapFailure f = ListT . wrapFailure f . runListT
+
+instance WrapFailure e 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
+  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
+  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
+  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
+  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
+  wrapFailure f m = Strict.RWST $ \r s -> wrapFailure f (Strict.runRWST m r s)
diff --git a/Control/Monad/Failure/Mtl.hs b/Control/Monad/Failure/Mtl.hs
deleted file mode 100644
--- a/Control/Monad/Failure/Mtl.hs
+++ /dev/null
@@ -1,76 +0,0 @@
-{-# LANGUAGE MultiParamTypeClasses #-}
-{-# LANGUAGE UndecidableInstances #-}
-{-# LANGUAGE FlexibleInstances #-}
-
-module Control.Monad.Failure.Mtl (module Control.Monad.Failure.Class) where
-
-import Control.Monad.Failure.Class
-
-import Control.Monad.Error
-import Control.Monad.List
-import Control.Monad.Reader
-import Control.Monad.State.Lazy     as Lazy
-import Control.Monad.State.Strict   as Strict
-import Control.Monad.Writer.Lazy    as Lazy
-import Control.Monad.Writer.Strict  as Strict
-import Control.Monad.RWS.Lazy       as Lazy
-import Control.Monad.RWS.Strict     as Strict
-import Data.Monoid
-
--- -----------------------
--- MonadFailure Instances
--- -----------------------
-
-instance (Error e, Monad m) => MonadFailure e (ErrorT e m) where
-  failure = throwError
-
-instance MonadFailure e m => MonadFailure e (ListT m) where
-  failure = lift . failure
-
-instance MonadFailure e m => MonadFailure e (ReaderT r m) where
-  failure = lift . failure
-
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.WriterT w  m) where
-  failure = lift . failure
-
-instance MonadFailure e m => MonadFailure e (Lazy.StateT s m) where
-  failure = lift . failure
-
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Lazy.RWST r w s m) where
-  failure = lift . failure
-
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.WriterT w  m) where
-  failure = lift . failure
-
-instance MonadFailure e m => MonadFailure e (Strict.StateT s m) where
-  failure = lift . failure
-
-instance (Monoid w, MonadFailure e m) => MonadFailure e (Strict.RWST r w s m) where
-  failure = lift . failure
-
--- ---------------------
--- WrapFailure instances
--- ---------------------
-
-instance WrapFailure e m => WrapFailure e (ListT m) where
-  wrapFailure f = ListT . wrapFailure f . runListT
-
-instance WrapFailure e 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
-  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
-  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
-  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
-  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
-  wrapFailure f m = Strict.RWST $ \r s -> wrapFailure f (Strict.runRWST m r s)
diff --git a/control-monad-failure.cabal b/control-monad-failure.cabal
--- a/control-monad-failure.cabal
+++ b/control-monad-failure.cabal
@@ -1,6 +1,6 @@
 name: control-monad-failure
-version: 0.2
-Cabal-Version:  >= 1.2.3
+version: 0.3
+Cabal-Version:  >= 1.6
 build-type: Simple
 license: PublicDomain
 author: Pepe Iborra, Michael Snoyman, Nicolas Pouillard
@@ -26,4 +26,8 @@
   if flag(mtl)
     cpp-options: -DMTL
     build-depends: mtl
-    exposed-modules: Control.Monad.Failure.Mtl
+    exposed-modules: Control.Monad.Failure.MTL
+
+source-repository head
+  type:     git
+  location: git://github.com/pepeiborra/control-monad-failure.git