diff --git a/explicit-exception.cabal b/explicit-exception.cabal
--- a/explicit-exception.cabal
+++ b/explicit-exception.cabal
@@ -1,5 +1,5 @@
 Name:             explicit-exception
-Version:          0.1.7.1
+Version:          0.1.7.2
 License:          BSD3
 License-File:     LICENSE
 Author:           Henning Thielemann <haskell@henning-thielemann.de>
@@ -36,6 +36,7 @@
    However note that freeing resources in case of an error is dangerous
    and may cause further damage.
 Tested-With:       GHC==6.8.2
+Tested-With:       GHC==7.4.2, GHC==7.6.1, GHC==7.8.2
 Cabal-Version:     >=1.6
 Build-Type:        Simple
 
@@ -46,10 +47,10 @@
 Source-Repository this
   type:     darcs
   location: http://code.haskell.org/explicit-exception/
-  tag:      0.1.7.1
+  tag:      0.1.7.2
 
 Flag buildTests
-  description: Build test suite
+  description: Build executables that demonstrate some space leaks
   default:     False
 
 Flag splitBase
diff --git a/src/Control/Monad/Exception/Asynchronous/Lazy.hs b/src/Control/Monad/Exception/Asynchronous/Lazy.hs
--- a/src/Control/Monad/Exception/Asynchronous/Lazy.hs
+++ b/src/Control/Monad/Exception/Asynchronous/Lazy.hs
@@ -45,15 +45,18 @@
 
 import qualified Control.Monad.Exception.Synchronous as Sync
 
-import Control.Monad (mplus, liftM, join, )
+import Control.Monad (Monad, return, liftM, mplus, join, (>>=), (>>), )
 import Control.Applicative (Applicative, liftA, )
+import Data.Functor (Functor, fmap, )
 {-
 import Data.Traversable (Traversable, )
 import Data.Foldable (Foldable, )
 -}
 import Data.Monoid(Monoid, mappend, mempty, )
+import Data.Function (const, (.), ($), )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
 
-import Prelude hiding (zipWith, sequence, mapM, )
+import Prelude (Show, )
 
 
 -- * Plain monad
diff --git a/src/Control/Monad/Exception/Asynchronous/Strict.hs b/src/Control/Monad/Exception/Asynchronous/Strict.hs
--- a/src/Control/Monad/Exception/Asynchronous/Strict.hs
+++ b/src/Control/Monad/Exception/Asynchronous/Strict.hs
@@ -45,15 +45,18 @@
 
 import qualified Control.Monad.Exception.Synchronous as Sync
 
-import Control.Monad (mplus, liftM, join, )
+import Control.Monad (Monad, return, liftM, mplus, join, (>>=), (>>), )
 import Control.Applicative (Applicative, liftA, )
+import Data.Functor (Functor, fmap, )
 {-
 import Data.Traversable (Traversable, )
 import Data.Foldable (Foldable, )
 -}
 import Data.Monoid(Monoid, mappend, mempty, )
+import Data.Function (const, (.), ($), )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
 
-import Prelude hiding (zipWith, sequence, mapM, )
+import Prelude (Show, )
 
 
 -- * Plain monad
diff --git a/src/Control/Monad/Exception/Label.hs b/src/Control/Monad/Exception/Label.hs
--- a/src/Control/Monad/Exception/Label.hs
+++ b/src/Control/Monad/Exception/Label.hs
@@ -12,6 +12,7 @@
 
 import Control.Monad.Exception.Synchronous (ExceptionalT, mapExceptionT, )
 import Control.Monad.Label (LabelT, )
+import Control.Applicative (Applicative, )
 
 import Control.Monad (liftM, )
 import Control.Monad.Fix (MonadFix, )
@@ -24,7 +25,7 @@
 newtype LabeledExceptionalT l e m a =
    LabeledExceptionalT
       {runLabeledExceptionalT :: LabelT l (ExceptionalT (LabeledException l e) m) a}
-      deriving (Monad, MonadFix)
+      deriving (Functor, Applicative, Monad, MonadFix)
 
 
 runLabelT :: (Monad m) =>
diff --git a/src/Control/Monad/Exception/Synchronous.hs b/src/Control/Monad/Exception/Synchronous.hs
--- a/src/Control/Monad/Exception/Synchronous.hs
+++ b/src/Control/Monad/Exception/Synchronous.hs
@@ -64,16 +64,23 @@
    ) where
 
 import Control.Applicative (Applicative(pure, (<*>)))
-import Control.Monad (liftM, liftM2, {- MonadPlus(mzero, mplus), -})
+import Control.Monad (Monad, return, fail, liftM, liftM2, (>>=), (>>), (=<<),
+          {- MonadPlus(mzero, mplus), -})
 import Control.Monad.Fix (MonadFix, mfix, )
 import Control.Monad.Trans.Class (MonadTrans, lift, )
 import Control.Monad.Trans.Error (ErrorT(ErrorT, runErrorT))
 import Control.Monad.Trans.Maybe (MaybeT(MaybeT, runMaybeT))
+import Data.Functor (Functor, fmap, )
 import Data.Monoid(Monoid, mappend, mempty, Endo(Endo, appEndo), )
+import Data.Function (flip, const, (.), ($), )
+import Data.Either (Either(Left, Right), either, )
+import Data.Maybe (Maybe(Just, Nothing), maybe, )
+import Data.Bool (Bool, )
+import Data.Eq (Eq, )
 
 import System.Exit (ExitCode(ExitSuccess, ExitFailure), )
 
-import Prelude hiding (catch, )
+import Prelude (Show, Int, error, )
 
 
 -- * Plain monad
diff --git a/src/Control/Monad/Label.hs b/src/Control/Monad/Label.hs
--- a/src/Control/Monad/Label.hs
+++ b/src/Control/Monad/Label.hs
@@ -14,7 +14,7 @@
 -}
 module Control.Monad.Label where
 
-import Control.Applicative (Applicative(pure, (<*>)))
+import Control.Applicative (Applicative(pure, (<*>)), Alternative, )
 
 import Control.Monad (MonadPlus, ap, )
 import Control.Monad.Fix (MonadFix)
@@ -22,7 +22,6 @@
 import Control.Monad.Trans.Class (MonadTrans, )
 import qualified Control.Monad.Trans.Reader as Reader
 import Control.Monad.Trans.Reader (Reader, ReaderT(ReaderT), runReader, runReaderT, )
-import Control.Monad.Instances ()
 
 
 -- * Plain monad
@@ -67,7 +66,7 @@
 
 newtype LabelT l m a = LabelT { runLabelPrivT :: ReaderT [l] m a }
 -- newtype LabelT l m a = LabelT { runLabelPrivT :: l -> m a }
-   deriving (Monad, MonadPlus, MonadFix, MonadTrans, MonadIO)
+   deriving (Alternative, Monad, MonadPlus, MonadFix, MonadTrans, MonadIO)
 
 {-
 instance (Monad m) => Functor (LabelT l m) where
diff --git a/src/System/IO/Straight.hs b/src/System/IO/Straight.hs
--- a/src/System/IO/Straight.hs
+++ b/src/System/IO/Straight.hs
@@ -17,6 +17,7 @@
    (Exceptional(Success, Exception), ExceptionalT(ExceptionalT), )
 import Control.Exception (IOException, try)
 import Control.Monad.IO.Class (MonadIO, liftIO, )
+import Control.Applicative (Applicative, )
 
 import System.IO.Unsafe (unsafeInterleaveIO, )
 
@@ -27,7 +28,7 @@
 However an 'error' can well break the program.
 -}
 newtype SIO a = SIO (IO a) -- {sioToIO :: IO a}
-   deriving (Functor, Monad)
+   deriving (Functor, Applicative, Monad)
 
 
 sioToIO :: SIO a -> IO a