diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,8 @@
+# 0.2.2
+* Add `genericInvmap` function (and make it the default implementation of
+  `invmap` for `Invariant` instances) on GHC 7.2 or later
+* Make `Tagged` instance poly-kinded
+
 # 0.2.1
 * Add `Foldable` and `Traversable` instances for `WrappedFunctor`
 * Fixed build on GHC HEAD
diff --git a/invariant.cabal b/invariant.cabal
--- a/invariant.cabal
+++ b/invariant.cabal
@@ -1,5 +1,5 @@
 name:                invariant
-version:             0.2.1
+version:             0.2.2
 synopsis:            Haskell 98 invariant functors
 description:         Haskell 98 invariant functors
 category:            Control, Data
@@ -9,7 +9,7 @@
 bug-reports:         https://github.com/nfrisby/invariant-functors/issues
 author:              Nicolas Frisby <nicolas.frisby@gmail.com>
 maintainer:          Nicolas Frisby <nicolas.frisby@gmail.com>,
-                     Ryan Scott <ryan.gl.scott@ku.edu>
+                     Ryan Scott <ryan.gl.scott@gmail.com>
 build-type:          Simple
 cabal-version:       >= 1.9.2
 extra-source-files:  CHANGELOG.md, README.md
diff --git a/src/Data/Functor/Invariant.hs b/src/Data/Functor/Invariant.hs
--- a/src/Data/Functor/Invariant.hs
+++ b/src/Data/Functor/Invariant.hs
@@ -3,6 +3,15 @@
 
 #define GHC_GENERICS_OK __GLASGOW_HASKELL__ >= 702
 
+#if GHC_GENERICS_OK
+{-# LANGUAGE DefaultSignatures #-}
+{-# LANGUAGE FlexibleContexts #-}
+#endif
+
+#if __GLASGOW_HASKELL__ >= 706
+{-# LANGUAGE PolyKinds #-}
+#endif
+
 {-|
 Module:      Data.Functor.Invariant
 Copyright:   (C) 2012-2015 Nicolas Frisby, (C) 2015 Ryan Scott
@@ -21,13 +30,14 @@
   ( -- * @Invariant@
     Invariant(..)
   , invmapFunctor
-  , WrappedFunctor(..)
-  , invmapContravariant
-  , WrappedContravariant(..)
 #if GHC_GENERICS_OK
     -- ** @GHC.Generics@
     -- $ghcgenerics
+  , genericInvmap
 #endif
+  , WrappedFunctor(..)
+  , invmapContravariant
+  , WrappedContravariant(..)
     -- * @Invariant2@
   , Invariant2(..)
   , invmap2Bifunctor
@@ -146,6 +156,10 @@
 -- > invmap f2 f2' . invmap f1 f1' = invmap (f2 . f1) (f1' . f2')
 class Invariant f where
   invmap :: (a -> b) -> (b -> a) -> f a -> f b
+#if GHC_GENERICS_OK
+  default invmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b
+  invmap = genericInvmap
+#endif
 
 -- | Every 'Functor' is also an 'Invariant' functor.
 invmapFunctor :: Functor f => (a -> b) -> (b -> a) -> f a -> f b
@@ -739,30 +753,28 @@
 instance (Invariant f, Invariant g) => Invariant ((:.:) f g) where
   invmap f g (Comp1 fgp) = Comp1 $ invmap (invmap f g) (invmap g f) fgp
 
-
 {- $ghcgenerics
-
-Note: The restriction to Haskell98 prevents the full adoption of
-"GHC.Generics", but we are permitted to at least provide @Invariant@
-instances for the representation data types. Thus, while the \"ideal\"
+With GHC 7.2 or later, 'Invariant' instances can be defined easily using GHC
+generics like so:
 
 @
-  instance Invariant f => 'Invariant' (T f)
-@
+&#123;-&#35; LANGUAGE DeriveGeneric, FlexibleContexts &#35;-&#125;
 
-doesn't work --- because Haskell98 precludes our use of
-@-XDefaultSignatures@ in the class definition ---, the user only needs
-to do slightly more work:
+import Data.Functor.Invariant
+import GHC.Generics
 
-@
-  import GHC.Generics (from1,to1)
+data T f a = T (f a) deriving Generic1
 
-  instance Invariant f => 'Invariant' (T f) where
-    invmap f g = 'to1' . 'invmap' f g . 'from1'
+instance Invariant f => 'Invariant' (T f)
 @
 
-Note also that that instance is in fact Haskell98. Unfortunately, one
-would require @-XFlexibleContexts@ in order to factor that right-hand
-side out as reusable declaration polymorphic in the data type.
+Be aware that generic 'Invariant' instances cannot be derived for data types
+that have function arguments in which the last type parameter appears in a
+position other than the result type (e.g., @data Fun a = Fun (a -> a)@). For
+these, you can derive them using the "Data.Functor.Invariant.TH" module.
 -}
+
+-- | A generic implementation of 'invmap'.
+genericInvmap :: (Generic1 f, Invariant (Rep1 f)) => (a -> b) -> (b -> a) -> f a -> f b
+genericInvmap f g = to1 . invmap f g . from1
 #endif
diff --git a/src/Data/Functor/Invariant/TH/Internal.hs b/src/Data/Functor/Invariant/TH/Internal.hs
--- a/src/Data/Functor/Invariant/TH/Internal.hs
+++ b/src/Data/Functor/Invariant/TH/Internal.hs
@@ -13,9 +13,8 @@
 
 import           Data.Function (on)
 import           Data.List
-import qualified Data.Map as Map (fromList, lookup)
+import qualified Data.Map as Map (fromList, findWithDefault)
 import           Data.Map (Map)
-import           Data.Maybe
 import qualified Data.Set as Set
 import           Data.Set (Set)
 
@@ -69,7 +68,7 @@
 
 subst :: Subst -> Type -> Type
 subst subs (ForallT v c t) = ForallT v c $ subst subs t
-subst subs t@(VarT n)      = fromMaybe t $ Map.lookup n subs
+subst subs t@(VarT n)      = Map.findWithDefault t n subs
 subst subs (AppT t1 t2)    = AppT (subst subs t1) (subst subs t2)
 subst subs (SigT t k)      = SigT (subst subs t) k
 subst _ t                  = t