diff --git a/Control/Monad/Catch.hs b/Control/Monad/Catch.hs
--- a/Control/Monad/Catch.hs
+++ b/Control/Monad/Catch.hs
@@ -5,6 +5,36 @@
   , FunctionalDependencies
   , MultiParamTypeClasses
   , UndecidableInstances #-}
+{- |
+License: BSD-style (see the file LICENSE)
+Maintainer: Andy Sonnenburg <andy22286@gmail.com>
+Stability: experimental
+Portability: non-portable
+
+[Computation type:]
+Computations which may fail or throw exceptions; and computations which may
+catch failures and thrown exceptions.
+
+[Binding strategy:]
+Failure records information about the cause/location of the failure.  Failure
+values bypass the bound function; other values are used as inputs to the bound
+function (same as @'Control.Monad.Error.Class.MonadError'@).
+
+[Useful for:]
+Building computations from sequences of functions that may fail; and using
+exception handling to structure error handling.  The handler may or may not
+throw an exception, which does not have to be of the same type as the original
+thrown exception (see @'mapE'@).
+
+[Zero and plus:]
+Zero is represented by an empty error, and the plus operation executes its second
+argument if the first fails (same as @'Control.Monad.Error.Class.MonadError'@).
+
+[Example type:]
+@'Either' 'String' a@
+
+The Throw and Catch monads.
+-}
 module Control.Monad.Catch
        ( MonadThrow (..)
        , MonadCatch (..)
@@ -14,37 +44,85 @@
        , WrappedMonadCatch (..)
        ) where
 
-import Control.Exception (IOException)
-import Control.Monad.Error hiding (MonadError)
+import Control.Exception (IOException, ioError)
+import qualified Control.Exception as Exception
+import Control.Monad
 import qualified Control.Monad.Error.Class as Error
+import Control.Monad.Trans.Class
+import Control.Monad.Trans.Error
 import Control.Monad.Trans.Identity
 import Control.Monad.Trans.List
 import Control.Monad.Trans.Maybe
 import Control.Monad.Trans.Reader
-import qualified Control.Monad.Trans.RWS.Lazy as Lazy
-import qualified Control.Monad.Trans.RWS.Strict as Strict
-import qualified Control.Monad.Trans.State.Lazy as Lazy
-import qualified Control.Monad.Trans.State.Strict as Strict
-import qualified Control.Monad.Trans.Writer.Lazy as Lazy
-import qualified Control.Monad.Trans.Writer.Strict as Strict
+import qualified Control.Monad.Trans.RWS.Lazy as LazyRWS
+import qualified Control.Monad.Trans.RWS.Strict as StrictRWS
+import qualified Control.Monad.Trans.State.Lazy as LazyState
+import qualified Control.Monad.Trans.State.Strict as StrictState
+import qualified Control.Monad.Trans.Writer.Lazy as LazyWriter
+import qualified Control.Monad.Trans.Writer.Strict as StrictWriter
 
 import Data.Monoid
 
+import Prelude (Either (..), IO, ($), (.), either, id)
+
+{- |
+The strategy of combining computations that can throw exceptions.
+
+Is parameterized over the type of error information and the monad type
+constructor.  It is common to use @'Either' 'String'@.  In some cases you will
+have to define an instance of @'MonadThrow'@, though rarely a definition of
+@'throw'@
+-}
 class Monad m => MonadThrow e m | m -> e where
+  {- |
+  Is used within a monadic computation to begin exception processing.  If
+  @('MonadThrow' e n, 'MonadTrans' t) => t n ~ m@, then @'throw' = 'lift' '.' 'throw'@
+  is the default definition.
+  -}
   throw :: e -> m a
   default throw :: (MonadThrow e m, MonadTrans t) => e -> t m a
   throw = lift . throw
 
+{-|
+The strategy of combining computations that can handle thrown exceptions,
+as well as throwing exceptions in the original computation.
+
+Is parameterized over the type of error information and the original monad type
+constructor, as well as the handler monad type constructor.  The handler monad
+type constructor commonly differs from the original monad type constructor due
+to a change in the type of the error information.
+-}
 class ( MonadThrow e m
       , Monad n
       ) => MonadCatch e m n | m -> e, n e -> m where
+  {- |
+  A handler function to handle thrown values and return to normal execution.
+  A common idiom is:
+
+  > do { action1; action2; action3 } `catch` handler
+
+  where the @action@ functions can call 'throw'.
+  Note that @handler@ and the do-block must have the same return type.
+  -}
   catch :: m a -> (e -> n a) -> n a
 
 type MonadError e m = (MonadThrow e m, MonadCatch e m m)
 
-mapE :: (MonadThrow e' n, MonadCatch e m n) => (e -> e') -> m a -> n a
+-- | Map the thrown value using the given function
+mapE :: (MonadCatch e m n, MonadThrow e' n) => (e -> e') -> m a -> n a
 mapE f m = m `catch` (throw . f)
 
+instance MonadThrow IOException IO where
+  throw = ioError
+instance MonadCatch IOException IO IO where
+  catch = Exception.catch
+
+instance MonadThrow e (Either e) where
+  throw = Left
+instance MonadCatch e (Either e) (Either e') where
+  Left e `catch` h = h e
+  Right a `catch` _h = Right a
+
 instance (Error e, Monad m) => MonadThrow e (ErrorT e m) where
   throw = throwError
 instance ( Error e
@@ -67,57 +145,50 @@
 
 instance MonadThrow e m => MonadThrow e (ReaderT r m)
 instance MonadCatch e m n => MonadCatch e (ReaderT r m) (ReaderT r n) where
-  m `catch` h = ReaderT $ \ r -> runReaderT m r `catch` \ e -> runReaderT (h e) r
+  m `catch` h =
+    ReaderT $ \ r -> runReaderT m r `catch` \ e -> runReaderT (h e) r
 
-instance (Monoid w, MonadThrow e m) => MonadThrow e (Lazy.RWST r w s m)
+instance (Monoid w, MonadThrow e m) => MonadThrow e (LazyRWS.RWST r w s m)
 instance (Monoid w, MonadCatch e m n) =>
-         MonadCatch e (Lazy.RWST r w s m) (Lazy.RWST r w s n) where
-  m `catch` h =
-    Lazy.RWST $ \ r s -> Lazy.runRWST m r s `catch` \ e -> Lazy.runRWST (h e) r s
+         MonadCatch e (LazyRWS.RWST r w s m) (LazyRWS.RWST r w s n) where
+  m `catch` h = LazyRWS.RWST $ \ r s ->
+    LazyRWS.runRWST m r s `catch` \ e -> LazyRWS.runRWST (h e) r s
 
-instance (Monoid w, MonadThrow e m) => MonadThrow e (Strict.RWST r w s m)
+instance (Monoid w, MonadThrow e m) => MonadThrow e (StrictRWS.RWST r w s m)
 instance (Monoid w, MonadCatch e m n) =>
-         MonadCatch e (Strict.RWST r w s m) (Strict.RWST r w s n) where
-  m `catch` h = Strict.RWST $ \ r s ->
-    Strict.runRWST m r s `catch` \ e -> Strict.runRWST (h e) r s
+         MonadCatch e (StrictRWS.RWST r w s m) (StrictRWS.RWST r w s n) where
+  m `catch` h = StrictRWS.RWST $ \ r s ->
+    StrictRWS.runRWST m r s `catch` \ e -> StrictRWS.runRWST (h e) r s
 
-instance MonadThrow e m => MonadThrow e (Lazy.StateT s m)
+instance MonadThrow e m => MonadThrow e (LazyState.StateT s m)
 instance MonadCatch e m n =>
-         MonadCatch e (Lazy.StateT s m) (Lazy.StateT s n) where
-  m `catch` h = Lazy.StateT $ \ s ->
-    Lazy.runStateT m s `catch` \ e -> Lazy.runStateT (h e) s
+         MonadCatch e (LazyState.StateT s m) (LazyState.StateT s n) where
+  m `catch` h = LazyState.StateT $ \ s ->
+    LazyState.runStateT m s `catch` \ e -> LazyState.runStateT (h e) s
 
-instance MonadThrow e m => MonadThrow e (Strict.StateT s m)
+instance MonadThrow e m => MonadThrow e (StrictState.StateT s m)
 instance MonadCatch e m n =>
-         MonadCatch e (Strict.StateT s m) (Strict.StateT s n) where
-  m `catch` h = Strict.StateT $ \ s ->
-    Strict.runStateT m s `catch` \ e -> Strict.runStateT (h e) s
+         MonadCatch e (StrictState.StateT s m) (StrictState.StateT s n) where
+  m `catch` h = StrictState.StateT $ \ s ->
+    StrictState.runStateT m s `catch` \ e -> StrictState.runStateT (h e) s
 
-instance (Monoid w, MonadThrow e m) => MonadThrow e (Lazy.WriterT w m)
-instance ( Monoid w
-         , MonadCatch e m n
-         ) => MonadCatch e (Lazy.WriterT w m) (Lazy.WriterT w n) where
+instance (Monoid w, MonadThrow e m) => MonadThrow e (LazyWriter.WriterT w m)
+instance
+  ( Monoid w
+  , MonadCatch e m n
+  ) => MonadCatch e (LazyWriter.WriterT w m) (LazyWriter.WriterT w n) where
   m `catch` h =
-    Lazy.WriterT $ Lazy.runWriterT m `catch` \ e -> Lazy.runWriterT (h e)
+    LazyWriter.WriterT $
+    LazyWriter.runWriterT m `catch` \ e -> LazyWriter.runWriterT (h e)
 
-instance ( Monoid w
-         , MonadCatch e m n
-         ) => MonadCatch e (Strict.WriterT w m) (Strict.WriterT w n) where
+instance (Monoid w, MonadThrow e m) => MonadThrow e (StrictWriter.WriterT w m)
+instance
+  ( Monoid w
+  , MonadCatch e m n
+  ) => MonadCatch e (StrictWriter.WriterT w m) (StrictWriter.WriterT w n) where
   m `catch` h =
-    Strict.WriterT $ Strict.runWriterT m `catch` \ e -> Strict.runWriterT (h e)
-
-instance (Monoid w, MonadThrow e m) => MonadThrow e (Strict.WriterT w m)
-
-instance MonadThrow e (Either e) where
-  throw = Left
-instance MonadCatch e (Either e) (Either e') where
-  Left e `catch` h = h e
-  Right a `catch` _h = Right a
-
-instance MonadThrow IOException IO where
-  throw = throwError
-instance MonadCatch IOException IO IO where
-  catch = catchError
+    StrictWriter.WriterT $
+    StrictWriter.runWriterT m `catch` \ e -> StrictWriter.runWriterT (h e)
 
 newtype WrappedMonadError m a =
   WrapMonadError { unwrapMonadError :: m a
@@ -128,11 +199,12 @@
   m >>= f = WrapMonadError $ unwrapMonadError m >>= unwrapMonadError . f
 
 instance Error.MonadError e m => MonadThrow e (WrappedMonadError m) where
-  throw = WrapMonadError . throwError
+  throw = WrapMonadError . Error.throwError
 instance Error.MonadError e m =>
          MonadCatch e (WrappedMonadError m) (WrappedMonadError m) where
   m `catch` h =
-    WrapMonadError $ unwrapMonadError m `catchError` (unwrapMonadError . h)
+    WrapMonadError $
+    unwrapMonadError m `Error.catchError` (unwrapMonadError . h)
 
 newtype WrappedMonadCatch m a =
   WrapMonadCatch { unwrapMonadCatch :: m a
diff --git a/catch-fd.cabal b/catch-fd.cabal
--- a/catch-fd.cabal
+++ b/catch-fd.cabal
@@ -1,5 +1,5 @@
 name:                catch-fd
-version:             0.1.0.0
+version:             0.1.0.1
 cabal-version:       >= 1.6
 synopsis:            MonadThrow and MonadCatch, using functional dependencies
 description:         MonadThrow and MonadCatch, using functional dependencies
@@ -19,10 +19,4 @@
 library
   exposed-modules: Control.Monad.Catch 
   build-depends: base < 6, mtl == 2.1.*, transformers == 0.3.*
-  extensions:
-    ConstraintKinds
-    FlexibleInstances
-    FunctionalDependencies
-    MultiParamTypeClasses
-    UndecidableInstances
   ghc-options: -Wall