diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2011, Mikhail Vorozhtsov
+Copyright (c) 2011-2016, Mikhail Vorozhtsov
 All rights reserved.
 
 Redistribution and use in source and binary forms, with or without 
diff --git a/src/Control/Monad/Trans/Abort.hs b/src/Control/Monad/Trans/Abort.hs
--- a/src/Control/Monad/Trans/Abort.hs
+++ b/src/Control/Monad/Trans/Abort.hs
@@ -5,51 +5,95 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE UndecidableInstances #-}
 
+-- | Error monad transformer.
 module Control.Monad.Trans.Abort
-  ( Abort
-  , runAbort
-  , AbortT(..)
+  ( AbortT(..)
   , abort
   , recover
+  , Abort
+  , runAbort
   ) where
 
 import Data.Pointed
 import Data.Functor.Identity
-import Data.Functor.Alt
-import Data.Functor.Plus
 import Data.Functor.Bind
 import Data.Functor.Bind.Trans
-import Data.Default.Class
-import Control.Applicative
-import Control.Monad (ap, MonadPlus(..))
+#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,5,0)
+import Data.Functor.Classes
+#endif
+#if !MIN_VERSION_base(4,9,0)
+import Control.Applicative (Applicative(..))
+#endif
+import Control.Applicative (liftA2)
+import Control.Monad (ap)
 #if !MIN_VERSION_monad_control(1,0,0)
 import Control.Monad (liftM)
 #endif
+#if MIN_VERSION_base(4,9,0)
+import qualified Control.Monad.Fail as Fail
+#endif
 import Control.Monad.Base
 import Control.Monad.Fix
+#if MIN_VERSION_base(4,4,0)
+import Control.Monad.Zip (MonadZip(..))
+#endif
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Control
 import Control.Monad.IO.Class
 
+-- | A monad transformer that extends monad @μ@ with the ability
+--   to raise errors of type @e@ and to recover from them.
 newtype AbortT e μ α = AbortT { runAbortT ∷ μ (Either e α) }
 
-type Abort e α = AbortT e Identity α
+#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,5,0)
+instance (Eq f, Eq1 μ) ⇒ Eq1 (AbortT f μ) where
+  liftEq f m₁ m₂ = liftEq (liftEq f) (runAbortT m₁) (runAbortT m₂)
 
-runAbort ∷ Abort e α → Either e α
-runAbort = runIdentity . runAbortT
+instance (Ord f, Ord1 μ) ⇒ Ord1 (AbortT f μ) where
+  liftCompare f m₁ m₂ =
+    liftCompare (liftCompare f) (runAbortT m₁) (runAbortT m₂)
 
-instance Monad μ ⇒ Pointed (AbortT e μ) where
-  point = AbortT . return . Right
+instance (Show f, Show1 μ) ⇒ Show1 (AbortT f μ) where
+  liftShowsPrec sp sl d =
+      showsUnaryWith (liftShowsPrec sp' sl') "AbortT" d . runAbortT
+    where
+      sp' = liftShowsPrec sp sl
+      sl' = liftShowList sp sl
 
-instance Functor μ ⇒ Functor (AbortT e μ) where
-  fmap f = AbortT . fmap (fmap f) . runAbortT
+instance (Read f, Read1 μ) ⇒ Read1 (AbortT f μ) where
+  liftReadsPrec rp rl =
+      readsData $ readsUnaryWith (liftReadsPrec rp' rl') "AbortT" AbortT
+    where
+      rp' = liftReadsPrec rp rl
+      rl' = liftReadList rp rl
 
-instance (Functor μ, Monad μ) ⇒ Alt (AbortT e μ) where
-  m <!> m' = recover m (const m')
+instance (Eq f, Eq1 μ, Eq α) ⇒ Eq (AbortT f μ α) where
+  (==) = eq1
 
-instance (Functor μ, Monad μ, Default e) ⇒ Plus (AbortT e μ) where
-  zero = mzero
+instance (Ord f, Ord1 μ, Ord α) ⇒ Ord (AbortT f μ α) where
+  compare = compare1
 
+instance (Show f, Show1 μ, Show α) ⇒ Show (AbortT f μ α) where
+  showsPrec = showsPrec1
+
+instance (Read f, Read1 μ, Read α) ⇒ Read (AbortT f μ α) where
+  readsPrec = readsPrec1
+#endif
+
+instance Foldable μ ⇒ Foldable (AbortT e μ) where
+  foldMap f = foldMap (either (const mempty) f) . runAbortT
+
+instance Traversable μ ⇒ Traversable (AbortT e μ) where
+  traverse f = fmap AbortT
+             . traverse (either (pure . Left) (fmap Right . f))
+             . runAbortT
+
+instance Pointed μ ⇒ Pointed (AbortT e μ) where
+  point = AbortT . point . Right
+
+instance Functor μ ⇒ Functor (AbortT e μ) where
+  fmap f = AbortT . fmap (fmap f) . runAbortT
+
 instance (Functor μ, Monad μ) ⇒ Apply (AbortT e μ) where
   (<.>) = ap
 
@@ -57,10 +101,6 @@
   pure  = return
   (<*>) = ap
 
-instance (Functor μ, Monad μ, Default e) ⇒ Alternative (AbortT e μ) where
-  empty = zero
-  (<|>) = (<!>)
-
 instance (Functor μ, Monad μ) ⇒ Bind (AbortT e μ) where
   (>>-) = (>>=)
 
@@ -69,14 +109,21 @@
   m >>= f = AbortT $ runAbortT m >>= either (return . Left) (runAbortT . f)
   fail    = AbortT . fail
 
-instance (Monad μ, Default e) ⇒ MonadPlus (AbortT e μ) where
-  mzero = abort def
-  m `mplus` m' = recover m (const m')
+#if MIN_VERSION_base(4,9,0)
+instance Fail.MonadFail μ ⇒ Fail.MonadFail (AbortT f μ) where
+  fail = AbortT . Fail.fail
+#endif
 
 instance MonadFix μ ⇒ MonadFix (AbortT e μ) where
   mfix f = AbortT $ mfix $
     runAbortT . f . either (error "mfix(AbortT): Left") id
 
+#if MIN_VERSION_base(4,4,0)
+instance MonadZip μ ⇒ MonadZip (AbortT f μ) where
+  mzipWith f m₁ m₂ =
+    AbortT $ mzipWith (liftA2 f) (runAbortT m₁) (runAbortT m₂)
+#endif
+
 instance MonadIO μ ⇒ MonadIO (AbortT e μ) where
   liftIO = lift . liftIO
 
@@ -112,8 +159,17 @@
   restoreM     = defaultRestoreM unStMAbort
 #endif
 
+-- | Raise an error.
 abort ∷ Monad μ ⇒ e → AbortT e μ α
 abort = AbortT . return . Left
 
+-- | Recover from an error.
 recover ∷ Monad μ ⇒ AbortT e μ α → (e → AbortT e μ α) → AbortT e μ α
 recover m h = AbortT $ runAbortT m >>= either (runAbortT . h) (return . Right)
+
+-- | An alias for 'AbortT' over 'Identity'.
+type Abort e α = AbortT e Identity α
+
+-- | 'runAbortT' specialized for 'Abort'.
+runAbort ∷ Abort e α → Either e α
+runAbort = runIdentity . runAbortT
diff --git a/src/Control/Monad/Trans/Finish.hs b/src/Control/Monad/Trans/Finish.hs
--- a/src/Control/Monad/Trans/Finish.hs
+++ b/src/Control/Monad/Trans/Finish.hs
@@ -5,40 +5,92 @@
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE UndecidableInstances #-}
 
+-- | Short-circuit monad transformer.
 module Control.Monad.Trans.Finish
-  ( Finish
-  , runFinish
-  , runFinish'
-  , FinishT(..)
+  ( FinishT(..)
   , runFinishT'
   , finish
+  , Finish
+  , runFinish
+  , runFinish'
   ) where
 
 import Data.Pointed
 import Data.Functor.Identity
 import Data.Functor.Bind
 import Data.Functor.Bind.Trans
-import Control.Applicative
+#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,5,0)
+import Data.Functor.Classes
+#endif
+#if !MIN_VERSION_base(4,9,0)
+import Control.Applicative (Applicative(..))
+#endif
+import Control.Applicative (liftA2)
 import Control.Monad (ap)
 #if !MIN_VERSION_monad_control(1,0,0)
 import Control.Monad (liftM)
 #endif
+#if MIN_VERSION_base(4,9,0)
+import qualified Control.Monad.Fail as Fail
+#endif
 import Control.Monad.Base
 import Control.Monad.Fix
+#if MIN_VERSION_base(4,4,0)
+import Control.Monad.Zip (MonadZip(..))
+#endif
 import Control.Monad.Trans.Class
 import Control.Monad.Trans.Control
 import Control.Monad.IO.Class
 
+-- | A monad transformer that extends monad @μ@ with the ability
+--   to short-circuit computations with a value of type @f@.
+--
+-- @
+--   'runFinishT' $ do someStuff
+--                   'Control.Monad.when' condition $ 'finish' reason
+--                   otherwiseContinue
+-- @
+--
 newtype FinishT f μ α = FinishT { runFinishT ∷ μ (Either f α) }
 
-type Finish f α = FinishT f Identity α
+#if MIN_VERSION_base(4,9,0) || MIN_VERSION_transformers(0,5,0)
+instance (Eq f, Eq1 μ) ⇒ Eq1 (FinishT f μ) where
+  liftEq f m₁ m₂ = liftEq (liftEq f) (runFinishT m₁) (runFinishT m₂)
 
-runFinish ∷ Finish f α → Either f α
-runFinish = runIdentity . runFinishT
+instance (Ord f, Ord1 μ) ⇒ Ord1 (FinishT f μ) where
+  liftCompare f m₁ m₂ =
+    liftCompare (liftCompare f) (runFinishT m₁) (runFinishT m₂)
 
-instance Monad μ ⇒ Pointed (FinishT f μ) where
-  point = FinishT . return . Right
+instance (Show f, Show1 μ) ⇒ Show1 (FinishT f μ) where
+  liftShowsPrec sp sl d =
+      showsUnaryWith (liftShowsPrec sp' sl') "FinishT" d . runFinishT
+    where
+      sp' = liftShowsPrec sp sl
+      sl' = liftShowList sp sl
 
+instance (Read f, Read1 μ) ⇒ Read1 (FinishT f μ) where
+  liftReadsPrec rp rl =
+      readsData $ readsUnaryWith (liftReadsPrec rp' rl') "FinishT" FinishT
+    where
+      rp' = liftReadsPrec rp rl
+      rl' = liftReadList rp rl
+
+instance (Eq f, Eq1 μ, Eq α) ⇒ Eq (FinishT f μ α) where
+  (==) = eq1
+
+instance (Ord f, Ord1 μ, Ord α) ⇒ Ord (FinishT f μ α) where
+  compare = compare1
+
+instance (Show f, Show1 μ, Show α) ⇒ Show (FinishT f μ α) where
+  showsPrec = showsPrec1
+
+instance (Read f, Read1 μ, Read α) ⇒ Read (FinishT f μ α) where
+  readsPrec = readsPrec1
+#endif
+
+instance Pointed μ ⇒ Pointed (FinishT f μ) where
+  point = FinishT . point . Right
+
 instance Functor μ ⇒ Functor (FinishT f μ) where
   fmap f = FinishT . fmap (fmap f) . runFinishT
 
@@ -57,10 +109,21 @@
   m >>= f = FinishT $ runFinishT m >>= either (return . Left) (runFinishT . f)
   fail    = FinishT . fail
 
+#if MIN_VERSION_base(4,9,0)
+instance Fail.MonadFail μ ⇒ Fail.MonadFail (FinishT f μ) where
+  fail = FinishT . Fail.fail
+#endif
+
 instance MonadFix μ ⇒ MonadFix (FinishT f μ) where
   mfix f = FinishT $ mfix $
-    runFinishT . f . either (error "mfix(FinishT): Left") id
+    runFinishT . f . either (const $ error "mfix(FinishT): Left") id
 
+#if MIN_VERSION_base(4,4,0)
+instance MonadZip μ ⇒ MonadZip (FinishT f μ) where
+  mzipWith f m₁ m₂ =
+    FinishT $ mzipWith (liftA2 f) (runFinishT m₁) (runFinishT m₂)
+#endif
+
 instance MonadIO μ ⇒ MonadIO (FinishT f μ) where
   liftIO = lift . liftIO
 
@@ -96,11 +159,22 @@
   restoreM     = defaultRestoreM unStMFinish
 #endif
 
+-- | A version of 'runFinishT' for the cases where you don't need to
+--   distinguish between short-circuits and regular computation results.
 runFinishT' ∷ Monad μ ⇒ FinishT α μ α → μ α
 runFinishT' m = runFinishT m >>= return . either id id
 
-runFinish' ∷ Finish α α → α
-runFinish' = runIdentity . runFinishT'
-
+-- | Short-circuit the enclosing computation.
 finish ∷ Monad μ ⇒ f → FinishT f μ α
 finish = FinishT . return . Left
+
+-- | An alias for 'FinishT' over 'Identity'.
+type Finish f α = FinishT f Identity α
+
+-- | 'runFinishT' specialized for 'Finish'.
+runFinish ∷ Finish f α → Either f α
+runFinish = runIdentity . runFinishT
+
+-- | 'runFinishT'' specialized to 'Finish'.
+runFinish' ∷ Finish α α → α
+runFinish' = runIdentity . runFinishT'
diff --git a/transformers-abort.cabal b/transformers-abort.cabal
--- a/transformers-abort.cabal
+++ b/transformers-abort.cabal
@@ -1,18 +1,17 @@
 Name: transformers-abort
-Version: 0.5.0.1
+Version: 0.6
 Category: Control
 Stability: experimental
-Synopsis: A better error monad transformer
+Synopsis: Error and short-circuit monad transformers
 Description:
-  This package provides a better error monad transformer for
-  the @transformers@ package.
+  This package provides error and short-circuit monad transformers.
 
 Homepage: https://github.com/mvv/transformers-abort
 Bug-Reports: https://github.com/mvv/transformers-abort/issues
 
 Author: Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>
 Maintainer: Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>
-Copyright: 2011 Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>
+Copyright: 2011-2016 Mikhail Vorozhtsov <mikhail.vorozhtsov@gmail.com>
 License: BSD3
 License-File: LICENSE
 
@@ -25,13 +24,12 @@
 
 Library
   Build-Depends:
-    base               >= 4 && < 5,
-    transformers       >= 0.2,
-    transformers-base  >= 0.4,
-    semigroupoids      >= 1.2,
-    pointed            >= 2.0.1,
-    data-default-class >= 0.0.1,
-    monad-control      >= 0.3
+    base              >= 4 && < 5,
+    transformers      >= 0.2,
+    transformers-base >= 0.4,
+    semigroupoids     >= 1.2,
+    pointed           >= 2.0.1,
+    monad-control     >= 0.3
   Hs-Source-Dirs: src
   GHC-Options: -Wall
   Exposed-Modules: