diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -13,12 +13,12 @@
 
 matrix:
   include:
-    - env: CABALVER=1.16 GHCVER=7.4.2
+    - env: CABALVER=1.24 GHCVER=7.4.2
       compiler: ": #GHC 7.4.2"
-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.4.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}
-    - env: CABALVER=1.16 GHCVER=7.6.3
+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.4.2,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}
+    - env: CABALVER=1.24 GHCVER=7.6.3
       compiler: ": #GHC 7.6.3"
-      addons: {apt: {packages: [cabal-install-1.16,ghc-7.6.3,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}
+      addons: {apt: {packages: [cabal-install-1.24,ghc-7.6.3,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}
     - env: CABALVER=1.18 GHCVER=7.8.4
       compiler: ": #GHC 7.8.4"
       addons: {apt: {packages: [cabal-install-1.18,ghc-7.8.4,alex-3.1.4,happy-1.19.5], sources: [hvr-ghc]}}
diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,9 @@
+4.3
+---
+* Removed a spurious superclass constraint for `Applicative (StoreT g w)`
+* GHC 8 support
+* `comonad` 5 support
+
 4.2.2
 -----
 * Builds clean on GHC 7.10
diff --git a/adjunctions.cabal b/adjunctions.cabal
--- a/adjunctions.cabal
+++ b/adjunctions.cabal
@@ -1,6 +1,6 @@
 name:          adjunctions
 category:      Data Structures, Adjunctions
-version:       4.2.2
+version:       4.3
 license:       BSD3
 cabal-version: >= 1.6
 license-file:  LICENSE
@@ -40,20 +40,21 @@
     UndecidableInstances
 
   build-depends:
-    array         >= 0.3.0.2 && < 0.7,
-    base          >= 4       && < 5,
-    comonad       >= 4       && < 5,
-    containers    >= 0.3     && < 0.6,
-    contravariant >= 1       && < 2,
-    distributive  >= 0.4     && < 1,
-    free          >= 4       && < 5,
-    mtl           >= 2.0.1   && < 2.3,
-    profunctors   >= 4       && < 6,
-    tagged        >= 0.7     && < 1,
-    semigroupoids >= 4       && < 6,
-    semigroups    >= 0.11    && < 1,
-    transformers  >= 0.2     && < 0.5,
-    void          >= 0.5.5.1 && < 1
+    array               >= 0.3.0.2 && < 0.7,
+    base                >= 4       && < 5,
+    comonad             >= 4       && < 6,
+    containers          >= 0.3     && < 0.6,
+    contravariant       >= 1       && < 2,
+    distributive        >= 0.4     && < 1,
+    free                >= 4       && < 5,
+    mtl                 >= 2.0.1   && < 2.3,
+    profunctors         >= 4       && < 6,
+    tagged              >= 0.7     && < 1,
+    semigroupoids       >= 4       && < 6,
+    semigroups          >= 0.11    && < 1,
+    transformers        >= 0.2     && < 0.6,
+    transformers-compat >= 0.3     && < 1,
+    void                >= 0.5.5.1 && < 1
 
   exposed-modules:
     Control.Comonad.Representable.Store
diff --git a/src/Control/Comonad/Representable/Store.hs b/src/Control/Comonad/Representable/Store.hs
--- a/src/Control/Comonad/Representable/Store.hs
+++ b/src/Control/Comonad/Representable/Store.hs
@@ -95,7 +95,7 @@
 instance (ComonadApply w, Semigroup (Rep g), Representable g) => ComonadApply (StoreT g w) where
   StoreT ff m <@> StoreT fa n = StoreT (apRep <$> ff <@> fa) (m <> n)
 
-instance (Applicative w, Semigroup (Rep g), Monoid (Rep g), Representable g) => Applicative (StoreT g w) where
+instance (Applicative w, Monoid (Rep g), Representable g) => Applicative (StoreT g w) where
   pure a = StoreT (pure (pureRep a)) mempty
   StoreT ff m <*> StoreT fa n = StoreT (apRep <$> ff <*> fa) (m `mappend` n)
 
diff --git a/src/Control/Monad/Representable/Reader.hs b/src/Control/Monad/Representable/Reader.hs
--- a/src/Control/Monad/Representable/Reader.hs
+++ b/src/Control/Monad/Representable/Reader.hs
@@ -77,7 +77,9 @@
   ReaderT fm >>- f = ReaderT $ tabulate (\a -> index fm a >>- flip index a . getReaderT . f)
 
 instance (Representable f, Monad m) => Monad (ReaderT f m) where
+#if __GLASGOW_HASKELL__ < 710
   return = ReaderT . pureRep . return
+#endif
   ReaderT fm >>= f = ReaderT $ tabulate (\a -> index fm a >>= flip index a . getReaderT . f)
 
 #if __GLASGOW_HASKELL >= 704
diff --git a/src/Control/Monad/Representable/State.hs b/src/Control/Monad/Representable/State.hs
--- a/src/Control/Monad/Representable/State.hs
+++ b/src/Control/Monad/Representable/State.hs
@@ -147,7 +147,9 @@
   StateT m >>- f = StateT $ fmap (>>- rightAdjunctRep (runStateT . f)) m
 
 instance (Representable g, Monad m) => Monad (StateT g m) where
+#if __GLASGOW_VERSION__ < 710
   return = StateT . leftAdjunctRep return
+#endif
   StateT m >>= f = StateT $ fmap (>>= rightAdjunctRep (runStateT . f)) m
 
 instance Representable f => BindTrans (StateT f) where
diff --git a/src/Control/Monad/Trans/Adjoint.hs b/src/Control/Monad/Trans/Adjoint.hs
--- a/src/Control/Monad/Trans/Adjoint.hs
+++ b/src/Control/Monad/Trans/Adjoint.hs
@@ -50,7 +50,7 @@
   (<*>) = ap
 
 instance (Adjunction f g, Monad m) => Monad (AdjointT f g m) where
-  return = AdjointT . leftAdjunct return
+  return = pure
   AdjointT m >>= f = AdjointT $ fmap (>>= rightAdjunct (runAdjointT . f)) m
 
 -- | Exploiting this instance requires that we have the missing Traversables for Identity, (,)e and IdentityT
diff --git a/src/Control/Monad/Trans/Contravariant/Adjoint.hs b/src/Control/Monad/Trans/Contravariant/Adjoint.hs
--- a/src/Control/Monad/Trans/Contravariant/Adjoint.hs
+++ b/src/Control/Monad/Trans/Contravariant/Adjoint.hs
@@ -62,5 +62,5 @@
   (<*>) = ap
 
 instance (Adjunction f g, Comonad w) => Monad (AdjointT f g w) where
-  return = AdjointT . leftAdjunct extract
+  return = pure
   AdjointT m >>= f = AdjointT $ contramap (extend (rightAdjunct (runAdjointT . f))) m
diff --git a/src/Data/Functor/Adjunction.hs b/src/Data/Functor/Adjunction.hs
--- a/src/Data/Functor/Adjunction.hs
+++ b/src/Data/Functor/Adjunction.hs
@@ -48,10 +48,10 @@
 import Control.Comonad.Trans.Traced
 
 import Data.Functor.Identity
-import Data.Functor.Coproduct
 import Data.Functor.Compose
 import Data.Functor.Product
 import Data.Functor.Rep
+import Data.Functor.Sum
 import Data.Profunctor
 import Data.Void
 
@@ -89,7 +89,7 @@
 -- This can be used with the combinators from the @lens@ package.
 --
 -- @'adjuncted' :: 'Adjunction' f u => 'Iso'' (f a -> b) (a -> u b)@
-adjuncted :: (Adjunction f u, Profunctor p, Functor g) 
+adjuncted :: (Adjunction f u, Profunctor p, Functor g)
           => p (a -> u b) (g (c -> u d)) -> p (f a -> b) (g (f c -> d))
 adjuncted = dimap leftAdjunct (fmap rightAdjunct)
 {-# INLINE adjuncted #-}
@@ -181,12 +181,10 @@
   counit = rightAdjunct (rightAdjunct getCompose) . getCompose
 
 instance (Adjunction f g, Adjunction f' g') =>
-         Adjunction (Coproduct f f') (Product g g') where
-  unit a = Pair (leftAdjunct left a) (leftAdjunct right a)
-  counit = coproduct (rightAdjunct fstP) (rightAdjunct sndP)
-    where
-      fstP (Pair x _) = x
-      sndP (Pair _ x) = x
+         Adjunction (Sum f f') (Product g g') where
+  unit a = Pair (leftAdjunct InL a) (leftAdjunct InR a)
+  counit (InL l) = rightAdjunct (\(Pair x _) -> x) l
+  counit (InR r) = rightAdjunct (\(Pair _ x) -> x) r
 
 instance Adjunction f u =>
          Adjunction (Free f) (Cofree u) where
diff --git a/src/Data/Functor/Rep.hs b/src/Data/Functor/Rep.hs
--- a/src/Data/Functor/Rep.hs
+++ b/src/Data/Functor/Rep.hs
@@ -67,12 +67,16 @@
 import Control.Comonad.Cofree
 import Control.Monad.Trans.Identity
 import Control.Monad.Reader
+#if MIN_VERSION_base(4,4,0)
+import Data.Complex
+#endif
 import Data.Distributive
 import Data.Functor.Bind
 import Data.Functor.Identity
 import Data.Functor.Compose
 import Data.Functor.Extend
 import Data.Functor.Product
+import qualified Data.Monoid as Monoid
 import Data.Profunctor
 import Data.Proxy
 import Data.Sequence (Seq)
@@ -111,7 +115,7 @@
 -- This can be used with the combinators from the @lens@ package.
 --
 -- @'tabulated' :: 'Representable' f => 'Iso'' ('Rep' f -> a) (f a)@
-tabulated :: (Representable f, Representable g, Profunctor p, Functor h) 
+tabulated :: (Representable f, Representable g, Profunctor p, Functor h)
           => p (f a) (h (g b)) -> p (Rep f -> a) (h (Rep g -> b))
 tabulated = dimap tabulate (fmap index)
 {-# INLINE tabulated #-}
@@ -227,6 +231,28 @@
       k Seq.:< ks -> index (index as k) ks
   tabulate f = f Seq.empty :< tabulate (\k -> tabulate (f . (k Seq.<|)))
 
+instance Representable Monoid.Dual where
+  type Rep Monoid.Dual = ()
+  index (Monoid.Dual d) () = d
+  tabulate f = Monoid.Dual (f ())
+
+instance Representable Monoid.Product where
+  type Rep Monoid.Product = ()
+  index (Monoid.Product p) () = p
+  tabulate f = Monoid.Product (f ())
+
+instance Representable Monoid.Sum where
+  type Rep Monoid.Sum = ()
+  index (Monoid.Sum s) () = s
+  tabulate f = Monoid.Sum (f ())
+
+#if MIN_VERSION_base(4,4,0)
+instance Representable Complex where
+  type Rep Complex = Bool
+  index (r :+ i) key = if key then i else r
+  tabulate f = f False :+ f True
+#endif
+
 newtype Co f a = Co { unCo :: f a } deriving Functor
 
 instance Representable f => Representable (Co f) where
@@ -248,7 +274,7 @@
   (>>-) = bindRep
 
 instance Representable f => Monad (Co f) where
-  return = pureRep
+  return = pure
   (>>=) = bindRep
 
 #if defined(__GLASGOW_HASKELL__) && __GLASGOW_HASKELL__ >= 704