diff --git a/ChangeLog.md b/ChangeLog.md
--- a/ChangeLog.md
+++ b/ChangeLog.md
@@ -1,17 +1,39 @@
 # ChangeLog / ReleaseNotes
 
 
+## Version 2.2.0.0
+
+* Deprecating module `Control.Monad.TaggedException.Utilities`, definitions
+  from it were moved in to `Control.Monad.TaggedException.Core`. (**change**)
+* Type `Throws` has now instance for `Generic1`, but only on GHC >=7.10, due to
+  `PolyKinds`. (**new**)
+* `HiddenException` instances for `AllocationLimitExceeded` and `Void`, both
+  defined in base >=4.8. (**new**)
+* `HiddenException` instance for `TypeError`, defined in base >=4.9. (**new**)
+* Bumped upper bound of [transformers][] package to include 0.5.\* branch.
+  (**change**)
+
+
+## Version 2.1.0.1
+
+* Relaxing upper bound on [exceptions][] package to include versions up to
+  0.8.\*. (**new**)
+* Not uploaded on to [Hackage][], instead opted to modify package metadata of
+  [2.1.0.0](http://hackage.haskell.org/package/tagged-exception-core-2.1.0.0)
+  release.
+
+
 ## Version 2.1.0.0
 
-* Builds on GHC from 7.4 to 7.10, later with base 4.8. (change)
-* Bumping transformers bounds to include 0.4.\* versions. (change)
+* Builds on GHC from 7.4 to 7.10, later with base 4.8. (**change**)
+* Bumping [transformers][] bounds to include 0.4.\* versions. (**change**)
 * Dropped last threads of support for base <= 4.5; it hadn't worked anyway
   since [exceptions][] ==0.6 depend on base >=4.5 && <5. (breaking change)
 * Instances for [mtl][] >=2.1 package. Package [exceptions][] already depends
-  on [mtl][], so it doesn't make sense to shy away from them. (new)
-* Introduced unsafe functions (new):
+  on [mtl][], so it doesn't make sense to shy away from them. (**new**)
+* Introduced unsafe functions (**new**):
 
-    ````Haskell
+    ```Haskell
     liftCCLike
         :: (((a -> m b) -> m' c) -> m'' d)
         -> ((a -> Throws e m b) -> Throws e m' c) -> Throws e m'' d
@@ -25,13 +47,14 @@
         -> Throws e m b -> Throws e' n b
     ```
 
-* Documentation updates. (new)
+* Documentation updates. (**new**)
 * Uploaded to [Hackage][]:
   <http://hackage.haskell.org/package/tagged-exception-core-2.1.0.0>
 
 
 ## Version 2.0.0.0
 
+* First public release.
 * Rewritten to use classes from [exceptions][] package.
 * Uploaded to [Hackage][]:
   <http://hackage.haskell.org/package/tagged-exception-core-2.0.0.0>
@@ -47,3 +70,6 @@
 [mtl]:
   http://hackage.haskell.org/package/mtl
   "mtl package on Hackage"
+[transformers]:
+  http://hackage.haskell.org/package/transformers
+  "transformers package on Hackage"
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright (c) 2009-2015, Peter Trško
+Copyright (c) 2009-2016, Peter Trško
 
 All rights reserved.
 
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -1,6 +1,7 @@
 # Tagged Exception Core
 
 [![Hackage](http://img.shields.io/hackage/v/tagged-exception-core.svg)][Hackage: tagged-exception-core]
+[![Hackage Dependencies](https://img.shields.io/hackage-deps/v/tagged-exception-core.svg)](http://packdeps.haskellers.com/reverse/tagged-exception-core)
 [![Haskell Programming Language](https://img.shields.io/badge/language-Haskell-blue.svg)][Haskell.org]
 [![BSD3 License](http://img.shields.io/badge/license-BSD3-brightgreen.svg)][tl;dr Legal: BSD3]
 
@@ -13,13 +14,60 @@
 others may build on top of it.
 
 
+## Usage Example
 
+Example of reflecting reised exception in type:
+
+```Haskell
+{-# LANGUAGE DeriveDataTypeable #-}
+
+import Control.Exception (Exception)
+
+import Control.Monad.TaggedException (Throws)
+import qualified Control.Monad.TaggedException as E (liftT, throw)
+import Data.Typeable (Typeable)
+
+
+data NotReady = NotReady String
+    deriving (Show, Typeable)
+        -- Both required by Exception class
+
+instance Exception NotReady
+
+myFunction :: Input -> Throws NotReady IO Output
+myFunction input = do
+
+    -- ... some stuff ...
+
+    -- isReady :: Input -> IO Bool
+    ready <- E.liftT $ isReady input
+    unless ready
+        . E.throw $ NotReady "Resource of myFunction is not ready."
+
+    -- ... some other stuff ...
+```
+
+## License
+
+The BSD 3-Clause License, see [LICENSE][] file for details.
+
+
+## Contributions
+
+Contributions, pull requests and bug reports are welcome! Please don't be
+afraid to contact author using GitHub or by e-mail.
+
+
+
 [Hackage: tagged-exception-core]:
   http://hackage.haskell.org/package/tagged-exception-core
   "tagged-exception-core package on Hackage"
 [Haskell.org]:
   http://www.haskell.org
   "The Haskell Programming Language"
+[LICENSE]:
+  https://github.com/trskop/tagged-exception-core/blob/master/LICENSE
+  "License of endo package."
 [tl;dr Legal: BSD3]:
   https://tldrlegal.com/license/bsd-3-clause-license-%28revised%29
   "BSD 3-Clause License (Revised)"
diff --git a/src/Control/Monad/TaggedException.hs b/src/Control/Monad/TaggedException.hs
--- a/src/Control/Monad/TaggedException.hs
+++ b/src/Control/Monad/TaggedException.hs
@@ -2,7 +2,7 @@
 {-# OPTIONS_GHC -fno-warn-missing-import-lists #-}
 -- |
 -- Module:       $HEADER$
--- Copyright:    (c) 2009-2015 Peter Trško
+-- Copyright:    (c) 2009-2015, Peter Trško
 -- License:      BSD3
 --
 -- Stability:    provisional
@@ -232,7 +232,11 @@
     , module Control.Monad.TaggedException.Hidden
 
     -- ** Asynchronous exceptions and bracket family of functions
-    , module Control.Monad.TaggedException.Utilities
+    --
+    -- | These functions are exported as part of
+    -- "Control.Monad.TaggedException.Core" module, there is also module
+    -- "Control.Monad.TaggedException.Utilities", which reexports only
+    -- functions that make use of 'Control.Monad.Catch.MonadMask' type class.
 
     -- * Some related work
     --
@@ -271,7 +275,6 @@
 
 import Control.Monad.TaggedException.Core
 import Control.Monad.TaggedException.Hidden
-import Control.Monad.TaggedException.Utilities
 
 -- $usage
 --
diff --git a/src/Control/Monad/TaggedException/Core.hs b/src/Control/Monad/TaggedException/Core.hs
--- a/src/Control/Monad/TaggedException/Core.hs
+++ b/src/Control/Monad/TaggedException/Core.hs
@@ -1,8 +1,9 @@
 {-# LANGUAGE NoImplicitPrelude #-}
+{-# LANGUAGE RankNTypes #-}
 -- |
 -- Module:       $HEADER$
 -- Description:  Core functionality.
--- Copyright:    (c) 2009-2015 Peter Trško
+-- Copyright:    (c) 2009-2016, Peter Trško
 -- License:      BSD3
 --
 -- Stability:    provisional
@@ -24,6 +25,15 @@
     , onException
     , onException'
 
+    -- * Utilities
+    , bracket
+    , bracket'
+    , bracket_
+    , bracketOnError
+    , bracketOnError'
+    , finally
+    , finally'
+
     -- * Exception tag
     , Throws
 
@@ -47,11 +57,12 @@
     where
 
 import Control.Exception (Exception)
+import Control.Monad (Monad(return))
 import Data.Either (Either)
-import Data.Function ((.), flip)
+import Data.Function ((.), ($), const, flip)
 import Data.Functor (Functor)
 
-import Control.Monad.Catch (MonadCatch, MonadThrow)
+import Control.Monad.Catch (MonadCatch, MonadMask, MonadThrow)
 import qualified Control.Monad.Catch as Exceptions
 
 import Control.Monad.TaggedException.Internal.Throws (Throws(Throws))
@@ -65,6 +76,7 @@
     , insideTf2
     , joinT
     , joinT3
+    , liftMask
     , liftT1
     , liftT2
     , liftT3
@@ -441,7 +453,7 @@
 
 -- |
 --
--- Since @1.2.0.0@
+-- /Since 1.2.0.0/
 embedT :: (Exception e, MonadThrow m, MonadThrow m')
     => (m a -> Throws e m' b)
     -> Throws e m a -> Throws e m' b
@@ -449,3 +461,165 @@
 {-# INLINE embedT #-}
 
 -- }}} Exception tag -- Combinators -------------------------------------------
+
+-- {{{ Utilities --------------------------------------------------------------
+
+mask' :: MonadMask m => ((forall a. m a -> m a) -> m b) -> m b
+mask' = Exceptions.mask
+
+mask
+    :: (Exception e, MonadMask m)
+    => ((forall a. Throws e m a -> Throws e m a) -> Throws e m b)
+    -> Throws e m b
+mask = Unsafe.liftMask Exceptions.mask
+
+-- | Run computation afeter another even if exception was thrown. See also
+-- 'finally'', 'onException' and 'onException''.
+--
+-- Implemented as:
+--
+-- @
+-- m ``finally`` n = 'mask' $ \\restore -> do
+--     r <- restore m ``onException`` n
+--     _ <- 'liftT' n
+--     return r
+-- @
+finally
+    :: (Exception e, MonadMask m)
+    => Throws e m a
+    -- ^ Computation to run first
+    -> m b
+    -- ^ Computation to run afterward (even if exception @e@ was raised)
+    -> Throws e m a
+    -- ^ Returns the result of the first computation
+m `finally` n = mask $ \restore -> do
+    r <- restore m `onException` n
+    _ <- liftT n
+    return r
+
+-- | Run computation afeter another even if exception was thrown. See also
+-- 'finally', 'onException' and 'onException''.
+finally'
+    :: MonadMask m
+    => m a
+    -- ^ Computation to run first
+    -> m b
+    -- ^ Computation to run afterward (even if some exception was raised)
+    -> m a
+    -- ^ Returns the result of the first computation
+finally' = Exceptions.finally
+
+-- | Run computation surrounded by acquire and release computations. The
+-- release computation is executed even if \"in-between\" computation
+-- raises exception. See also 'bracket'', 'bracket_', 'bracketOnError',
+-- and 'bracketOnError''.
+bracket
+    :: (Exception e, MonadMask m)
+    => m a
+    -- ^ Computation to run before
+    -> (a -> m b)
+    -- ^ Computation to run after
+    -> (a -> Throws e m c)
+    -- ^ Computation to run in-between
+    -> Throws e m c
+    -- ^ Result of the in-between computation
+bracket acq rel go = mask $ \ restore -> do
+    x <- liftT acq
+    r <- restore (go x) `onException` rel x
+    _ <- liftT $ rel x
+    return r
+
+-- | Run computation surrounded by acquire and release computations. The
+-- release computation is executed even if \"in-between\" computation
+-- raises exception. See also 'bracket', 'bracket_', 'bracketOnError', and
+-- 'bracketOnError''.
+--
+-- Implementated as:
+--
+-- @
+-- 'bracket'' acq rel go = 'mask'' $ \\restore -> do
+--     x <- acq
+--     r <- restore (go x) ``onException'`` rel x
+--     _ <- rel x
+--     return r
+-- @
+bracket'
+    :: MonadMask m
+    => m a
+    -- ^ Computation to run before
+    -> (a -> m b)
+    -- ^ Computation to run after
+    -> (a -> m c)
+    -- ^ Computation to run in-between
+    -> m c
+    -- ^ Result of the in-between computation
+bracket' = Exceptions.bracket
+
+-- | Version of 'bracket' where \"after\" computation is executed only if
+-- \"in-between\" computation raises exception.
+--
+-- Implemented as:
+--
+-- @
+-- 'bracketOnError' acq rel go = 'mask' $ \\restore -> do
+--     x <- 'liftT' acq
+--     restore (go x) ``onException`` rel x
+-- @
+bracketOnError
+    :: (Exception e, MonadMask m)
+    => m a
+    -- ^ Computation to run before
+    -> (a -> m b)
+    -- ^ Computation to run after if an exception was raised
+    -> (a -> Throws e m c)
+    -- ^ Computation to run in-between
+    -> Throws e m c
+    -- ^ Result of the in-between computation
+bracketOnError acq rel go = mask $ \ restore -> do
+    x <- liftT acq
+    restore (go x) `onException` rel x
+
+-- | Version of 'bracket' where \"after\" computation is executed only if
+-- \"in-between\" computation raises exception.
+--
+-- Implemented as:
+--
+-- @
+-- 'bracketOnError'' acq rel go = 'mask'' $ \\restore -> do
+--     x <- 'liftT' acq
+--     restore (go x) ``onException'`` rel x
+-- @
+bracketOnError'
+    :: MonadMask m
+    => m a
+    -- ^ Computation to run before
+    -> (a -> m b)
+    -- ^ Computation to run after if an exception was raised
+    -> (a -> m c)
+    -- ^ Computation to run in-between
+    -> m c
+    -- ^ Result of the in-between computation
+bracketOnError' acq rel go = mask' $ \ restore -> do
+    x <- acq
+    restore (go x) `onException'` rel x
+
+-- | Variant of 'bracket'.
+--
+-- Implemented as:
+--
+-- @
+-- 'bracket_' acq rel go = 'bracket' acq ('const' rel) ('const' go)
+-- @
+bracket_
+    :: (Exception e, MonadMask m)
+    => m a
+    -- ^ Computation to run before
+    -> m b
+    -- ^ Computation to run after
+    -> Throws e m c
+    -- ^ Computation to run in-between
+    -> Throws e m c
+    -- ^ Result of the in-between computation
+bracket_ acq rel go = bracket acq (const rel) (const go)
+
+-- }}} Utilities --------------------------------------------------------------
diff --git a/src/Control/Monad/TaggedException/Hidden.hs b/src/Control/Monad/TaggedException/Hidden.hs
--- a/src/Control/Monad/TaggedException/Hidden.hs
+++ b/src/Control/Monad/TaggedException/Hidden.hs
@@ -3,7 +3,7 @@
 -- |
 -- Module:       $HEADER$
 -- Description:  Support for hidden exceptions.
--- Copyright:    (c) 2009 - 2014 Peter Trsko
+-- Copyright:    (c) 2009-2016, Peter Trško
 -- License:      BSD3
 --
 -- Stability:    provisional
@@ -65,7 +65,12 @@
 
 import Control.Exception (Exception)
 import qualified Control.Exception as E
+#if MIN_VERSION_base(4,8,0)
+    ( AllocationLimitExceeded
+    , ArithException
+#else
     ( ArithException
+#endif
     , ArrayException
     , AssertionFailed
     , AsyncException
@@ -90,9 +95,15 @@
     , SomeAsyncException
 #endif
     , SomeException
+#if MIN_VERSION_base(4,9,0)
+    , TypeError
+#endif
     )
 import Data.Dynamic (Dynamic)
 import Data.Function ((.))
+#if MIN_VERSION_base(4,8,0)
+import Data.Void (Void)
+#endif
 import System.Exit (ExitCode)
 
 import Control.Monad.Catch (MonadCatch, MonadThrow)
@@ -136,11 +147,21 @@
 instance HiddenException E.RecConError
 instance HiddenException E.RecSelError
 instance HiddenException E.RecUpdError
+instance HiddenException E.SomeException
+instance HiddenException ExitCode
+
 #if MIN_VERSION_base(4,7,0)
 instance HiddenException E.SomeAsyncException
 #endif
-instance HiddenException E.SomeException
-instance HiddenException ExitCode
+
+#if MIN_VERSION_base(4,8,0)
+instance HiddenException E.AllocationLimitExceeded
+instance HiddenException Void
+#endif
+
+#if MIN_VERSION_base(4,9,0)
+instance HiddenException E.TypeError
+#endif
 
 -- }}} HiddenException -- Instances -------------------------------------------
 
diff --git a/src/Control/Monad/TaggedException/Internal/Throws.hs b/src/Control/Monad/TaggedException/Internal/Throws.hs
--- a/src/Control/Monad/TaggedException/Internal/Throws.hs
+++ b/src/Control/Monad/TaggedException/Internal/Throws.hs
@@ -19,7 +19,7 @@
 -- |
 -- Module:       $HEADER$
 -- Description:  Data type for associating monadic value with phantom type.
--- Copyright:    (c) 2009 - 2015 Peter Trsko
+-- Copyright:    (c) 2009-2016, Peter Trško
 -- License:      BSD3
 --
 -- Maintainer:   peter.trsko@gmail.com
@@ -56,8 +56,13 @@
 import Data.Typeable (Typeable)
 #endif
 #ifdef GHC_GENERICS
-import GHC.Generics (Generic)
+import GHC.Generics
+    ( Generic
+#if __GLASGOW_HASKELL__ >= 710
+    , Generic1
 #endif
+    )
+#endif
 
 import Control.Monad.Cont.Class (MonadCont(callCC))
 import Control.Monad.Error.Class (MonadError(catchError, throwError))
@@ -85,6 +90,9 @@
     -- GHC Generics were introduced earlier then polykinded Typeable.
   deriving
     ( Generic
+#if __GLASGOW_HASKELL__ >= 710
+    , Generic1
+#endif
 #ifdef KIND_POLYMORPHIC_TYPEABLE
     , Typeable
 #endif
diff --git a/src/Control/Monad/TaggedException/Unsafe.hs b/src/Control/Monad/TaggedException/Unsafe.hs
--- a/src/Control/Monad/TaggedException/Unsafe.hs
+++ b/src/Control/Monad/TaggedException/Unsafe.hs
@@ -3,7 +3,7 @@
 -- Module:       $HEADER$
 -- Description:  Unsafe exception tag cobinators and specific lifting
 --               functions.
--- Copyright:    (c) 2009-2015 Peter Trsko
+-- Copyright:    (c) 2009-2015, Peter Trško
 -- License:      BSD3
 --
 -- Stability:    provisional
diff --git a/src/Control/Monad/TaggedException/Utilities.hs b/src/Control/Monad/TaggedException/Utilities.hs
--- a/src/Control/Monad/TaggedException/Utilities.hs
+++ b/src/Control/Monad/TaggedException/Utilities.hs
@@ -3,16 +3,23 @@
 -- |
 -- Module:       $HEADER$
 -- Description:  Utility functions built on top of core API.
--- Copyright:    (c) 2009-2014 Peter Trsko.
+-- Copyright:    (c) 2009-2015, Peter Trško
 -- License:      BSD3
 --
 -- Stability:    provisional
 -- Portability:  NoImplicitPrelude, RankNTypes
 --
 -- Utility functions built on top of core API.
+--
+-- Functions from this module were moved in to
+-- "Control.Monad.TaggedException.Core", and this module became deprecated.
+--
+-- For compatibility reasons this module re-exports all functions that were
+-- previously defined here, but this module will be removed in the future.
+-- Please update your code to use "Control.Monad.TaggedException.Core" instead.
 module Control.Monad.TaggedException.Utilities
-    (
-      bracket
+    {-# DEPRECATED "Use module Control.Monad.TaggedException.Core instead." #-}
+    ( bracket
     , bracket'
     , bracket_
     , bracketOnError
@@ -20,167 +27,14 @@
     , finally
     , finally'
     )
-    where
-
-import Control.Monad (Monad(return))
-import Control.Exception (Exception)
-import Data.Function (($), const)
-
-import Control.Monad.Catch (MonadMask)
-import qualified Control.Monad.Catch as Exceptions
+  where
 
 import Control.Monad.TaggedException.Core
-    ( liftT
-    , onException
-    , onException'
+    ( bracket
+    , bracket'
+    , bracket_
+    , bracketOnError
+    , bracketOnError'
+    , finally
+    , finally'
     )
-import Control.Monad.TaggedException.Internal.Throws (Throws)
-import qualified Control.Monad.TaggedException.Internal.Throws
-    as Unsafe (liftMask)
-
-
-mask' :: MonadMask m => ((forall a. m a -> m a) -> m b) -> m b
-mask' = Exceptions.mask
-
-mask
-    :: (Exception e, MonadMask m)
-    => ((forall a. Throws e m a -> Throws e m a) -> Throws e m b)
-    -> Throws e m b
-mask = Unsafe.liftMask Exceptions.mask
-
--- | Run computation afeter another even if exception was thrown. See also
--- 'finally'', 'onException' and 'onException''.
---
--- Default implementation:
---
--- > m `finally` n = mask $ \ restore -> do
--- >     r <- restore m `onException` n
--- >     _ <- liftT n
--- >     return r
-finally
-    :: (Exception e, MonadMask m)
-    => Throws e m a
-    -- ^ Computation to run first
-    -> m b
-    -- ^ Computation to run afterward (even if exception @e@ was raised)
-    -> Throws e m a
-    -- ^ Returns the result of the first computation
-m `finally` n = mask $ \restore -> do
-    r <- restore m `onException` n
-    _ <- liftT n
-    return r
-
--- | Run computation afeter another even if exception was thrown. See also
--- 'finally', 'onException' and 'onException''.
-finally'
-    :: MonadMask m
-    => m a
-    -- ^ Computation to run first
-    -> m b
-    -- ^ Computation to run afterward (even if some exception was raised)
-    -> m a
-    -- ^ Returns the result of the first computation
-finally' = Exceptions.finally
-
--- | Run computation surrounded by acquire and release computations. The
--- release computation is executed even if \"in-between\" computation
--- raises exception. See also 'bracket'', 'bracket_', 'bracketOnError',
--- and 'bracketOnError''.
-bracket
-    :: (Exception e, MonadMask m)
-    => m a
-    -- ^ Computation to run before
-    -> (a -> m b)
-    -- ^ Computation to run after
-    -> (a -> Throws e m c)
-    -- ^ Computation to run in-between
-    -> Throws e m c
-    -- ^ Result of the in-between computation
-bracket acq rel go = mask $ \ restore -> do
-    x <- liftT acq
-    r <- restore (go x) `onException` rel x
-    _ <- liftT $ rel x
-    return r
-
--- | Run computation surrounded by acquire and release computations. The
--- release computation is executed even if \"in-between\" computation
--- raises exception. See also 'bracket', 'bracket_', 'bracketOnError', and
--- 'bracketOnError''.
---
--- Default implementation:
---
--- > bracket' acq rel go = mask' $ \ restore -> do
--- >     x <- acq
--- >     r <- restore (go x) `onException'` rel x
--- >     _ <- rel x
--- >     return r
-bracket'
-    :: MonadMask m
-    => m a
-    -- ^ Computation to run before
-    -> (a -> m b)
-    -- ^ Computation to run after
-    -> (a -> m c)
-    -- ^ Computation to run in-between
-    -> m c
-    -- ^ Result of the in-between computation
-bracket' = Exceptions.bracket
-
--- | Version of 'bracket' where \"after\" computation is executed only if
--- \"in-between\" computation raises exception.
---
--- Default implementation:
---
--- > bracketOnError acq rel go = mask $ \ restore -> do
--- >     x <- liftT acq
--- >     restore (go x) `onException` rel x
-bracketOnError
-    :: (Exception e, MonadMask m)
-    => m a
-    -- ^ Computation to run before
-    -> (a -> m b)
-    -- ^ Computation to run after if an exception was raised
-    -> (a -> Throws e m c)
-    -- ^ Computation to run in-between
-    -> Throws e m c
-    -- ^ Result of the in-between computation
-bracketOnError acq rel go = mask $ \ restore -> do
-    x <- liftT acq
-    restore (go x) `onException` rel x
-
--- | Version of 'bracket' where \"after\" computation is executed only if
--- \"in-between\" computation raises exception.
---
--- Default implementation:
---
--- > bracketOnError' acq rel go = mask' $ \ restore -> do
--- >     x <- liftT acq
--- >     restore (go x) `onException'` rel x
-bracketOnError'
-    :: MonadMask m
-    => m a
-    -- ^ Computation to run before
-    -> (a -> m b)
-    -- ^ Computation to run after if an exception was raised
-    -> (a -> m c)
-    -- ^ Computation to run in-between
-    -> m c
-    -- ^ Result of the in-between computation
-bracketOnError' acq rel go = mask' $ \ restore -> do
-    x <- acq
-    restore (go x) `onException'` rel x
-
--- | Variant of 'bracket'.
---
--- > bracket_ acq rel go = bracket acq (const rel) (const go)
-bracket_
-    :: (Exception e, MonadMask m)
-    => m a
-    -- ^ Computation to run before
-    -> m b
-    -- ^ Computation to run after
-    -> Throws e m c
-    -- ^ Computation to run in-between
-    -> Throws e m c
-    -- ^ Result of the in-between computation
-bracket_ acq rel go = bracket acq (const rel) (const go)
diff --git a/tagged-exception-core.cabal b/tagged-exception-core.cabal
--- a/tagged-exception-core.cabal
+++ b/tagged-exception-core.cabal
@@ -1,5 +1,5 @@
 Name:               tagged-exception-core
-Version:            2.1.0.0
+Version:            2.2.0.0
 
 Synopsis:           Reflect exceptions using phantom types.
 Description:
@@ -7,9 +7,10 @@
   introduces @Throws@ monad transformer that uses phantom type to tag code that
   may raise exception.  Intention is to make exceptions explicit and to enforce
   exception handling.
-Homepage:           https://github.com/trskop/tagged-exception
-Bug-reports:        https://github.com/trskop/tagged-exception/issues
-Copyright:          Copyright (c) 2009-2015, Peter Trško
+
+Homepage:           https://github.com/trskop/tagged-exception-core
+Bug-reports:        https://github.com/trskop/tagged-exception-core/issues
+Copyright:          Copyright (c) 2009-2016, Peter Trško
 License:            BSD3
 License-file:       LICENSE
 Author:             Peter Trško
@@ -60,18 +61,26 @@
 
   Build-depends:
     -- {{{ Distributed with GHC or Haskell Platform ---------------------------
+
       base >= 4.5 && < 5
     -- ^ Same restrictions as exceptions 0.6 have.
-    , transformers >= 0.3 && < 0.5
+
+    , transformers >= 0.3 && < 0.6
     -- ^ Based on dependencies of mtl==2.1 and mtl==2.2.1
+
     -- }}} Distributed with GHC or Haskell Platform ---------------------------
 
-    , exceptions > 0.6 && < 0.7
+    , exceptions > 0.6 && < 0.9
     -- ^ Interface of this package changed a lot between minor versions,
     -- therefore trying conservative approach. Dependency introduced in
     -- tagged-exception-core-2.0.0.0.
+    --
+    -- From the used API view, there has been little changes between 0.6.1 and
+    -- 0.8.2.1 (newest at the time of writing).
+
     , mmorph >= 1.0.0 && < 1.1
     -- ^ Dependency introduced in tagged-exception-core-1.2.0.0.
+
     , mtl >=2.1 && <2.3
     -- ^ Dependency introduced in tagged-exception-core-2.0.1.0.
     -- Package exceptions already depends on it so it doesn't make sense to
@@ -80,8 +89,10 @@
   if impl(ghc >= 7.8.1)
     CPP-options:    -DKIND_POLYMORPHIC_TYPEABLE
 
-  if impl(ghc >= 7.6.1)
-    CPP-options:    -DGHC_GENERICS
+  CPP-options:      -DGHC_GENERICS
+  if impl(ghc < 7.6)
+    -- GHC.Generics moved from ghc-prim to base with GHC 7.6 release.
+    Build-depends:  ghc-prim
 
   GHC-options:      -Wall
   if flag(pedantic)
@@ -98,4 +109,4 @@
 source-repository this
   type:             git
   location:         git://github.com/trskop/tagged-exception-core.git
-  tag:              2.1.0.0
+  tag:              2.2.0.0