diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,9 @@
+3.7.3 [maintenance release]
+-----
+* Removed my intra-package dependency upper bounds for my own packages. In particular this enables us to work with `semigroups` 0.9.
+* Switched to `transformers-compat` to avoid having unbuilding modules at the top of the documentation, and to ease 3rd party compatibility.
+* Updated `Setup.lhs` to be compatible with Cabal 1.17
+
 3.7.2 [maintenance release]
 -----
 * Bug fix for `Magnify`. It was missing functional dependencies to determine its `k` parameter from `m` or `n`.
diff --git a/Setup.lhs b/Setup.lhs
--- a/Setup.lhs
+++ b/Setup.lhs
@@ -1,45 +1,44 @@
 #!/usr/bin/runhaskell
 \begin{code}
+{-# OPTIONS_GHC -Wall #-}
 module Main (main) where
 
 import Data.List ( nub )
 import Data.Version ( showVersion )
 import Distribution.Package ( PackageName(PackageName), PackageId, InstalledPackageId, packageVersion, packageName )
+import Distribution.PackageDescription ( PackageDescription(), TestSuite(..) )
 import Distribution.Simple ( defaultMainWithHooks, UserHooks(..), simpleUserHooks )
 import Distribution.Simple.Utils ( rewriteFile, createDirectoryIfMissingVerbose )
-import Distribution.Verbosity ( Verbosity )
 import Distribution.Simple.BuildPaths ( autogenModulesDir )
 import Distribution.Simple.Setup ( BuildFlags(buildVerbosity), fromFlag )
-import Distribution.Simple.LocalBuildInfo ( LocalBuildInfo(libraryConfig, testSuiteConfigs), ComponentLocalBuildInfo(componentPackageDeps) )
+import Distribution.Simple.LocalBuildInfo ( withLibLBI, withTestLBI, LocalBuildInfo(), ComponentLocalBuildInfo(componentPackageDeps) )
+import Distribution.Verbosity ( Verbosity )
 import System.FilePath ( (</>) )
 
 main :: IO ()
 main = defaultMainWithHooks simpleUserHooks
   { buildHook = \pkg lbi hooks flags -> do
-     generateBuildModule "doctests" (fromFlag (buildVerbosity flags)) lbi
+     generateBuildModule (fromFlag (buildVerbosity flags)) pkg lbi
      buildHook simpleUserHooks pkg lbi hooks flags
-  -- , haddockHook = \pkg lbi hooks flags -> do
-  --   generateBuildModule (fromFlag (haddockVerbosity flags)) lbi
-  --   haddockHook simpleUserHooks pkg lbi hooks flags
   }
 
-generateBuildModule :: String -> Verbosity -> LocalBuildInfo -> IO ()
-generateBuildModule testSuite verbosity lbi = do
+generateBuildModule :: Verbosity -> PackageDescription -> LocalBuildInfo -> IO ()
+generateBuildModule verbosity pkg lbi = do
   let dir = autogenModulesDir lbi
   createDirectoryIfMissingVerbose verbosity True dir
-  rewriteFile (dir </> "Build_" ++ testSuite ++ ".hs") $ unlines
-    [ "module Build_" ++ testSuite ++ " where"
-    , "deps :: [String]"
-    , "deps = " ++ (show $ formatdeps (testDeps testSuite lbi))
-    ]
+  withLibLBI pkg lbi $ \_ libcfg -> do
+    withTestLBI pkg lbi $ \suite suitecfg -> do
+      rewriteFile (dir </> "Build_" ++ testName suite ++ ".hs") $ unlines
+        [ "module Build_" ++ testName suite ++ " where"
+        , "deps :: [String]"
+        , "deps = " ++ (show $ formatdeps (testDeps libcfg suitecfg))
+        ]
   where
     formatdeps = map (formatone . snd)
     formatone p = case packageName p of
       PackageName n -> n ++ "-" ++ showVersion (packageVersion p)
 
-testDeps :: String -> LocalBuildInfo -> [(InstalledPackageId, PackageId)]
-testDeps testSuite lbi = nub $
-     maybe [] componentPackageDeps (lookup testSuite (testSuiteConfigs lbi))
-  ++ maybe [] componentPackageDeps (libraryConfig lbi)
+testDeps :: ComponentLocalBuildInfo -> ComponentLocalBuildInfo -> [(InstalledPackageId, PackageId)]
+testDeps xs ys = nub $ componentPackageDeps xs ++ componentPackageDeps ys
 
 \end{code}
diff --git a/compat/Control/Applicative/Backwards.hs b/compat/Control/Applicative/Backwards.hs
deleted file mode 100644
--- a/compat/Control/Applicative/Backwards.hs
+++ /dev/null
@@ -1,51 +0,0 @@
--- |
--- Module      :  Control.Applicative.Backwards
--- Copyright   :  (c) Russell O'Connor 2009
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  libraries@haskell.org
--- Stability   :  experimental
--- Portability :  portable
---
--- Making functors with an 'Applicative' instance that performs actions
--- in the reverse order.
---
--- NB: This module is only included in @lens@ for backwards compatibility with
--- @transformers@ versions before 3.0.
-module Control.Applicative.Backwards where
-
-import Prelude hiding (foldr, foldr1, foldl, foldl1)
-import Control.Applicative
-import Data.Foldable
-import Data.Traversable
-
--- | The same functor, but with an 'Applicative' instance that performs
--- actions in the reverse order.
-newtype Backwards f a = Backwards { forwards :: f a }
-
--- | Derived instance.
-instance (Functor f) => Functor (Backwards f) where
-    fmap f (Backwards a) = Backwards (fmap f a)
-
--- | Apply @f@-actions in the reverse order.
-instance (Applicative f) => Applicative (Backwards f) where
-    pure a = Backwards (pure a)
-    Backwards f <*> Backwards a = Backwards (a <**> f)
-
--- | Try alternatives in the same order as @f@.
-instance (Alternative f) => Alternative (Backwards f) where
-    empty = Backwards empty
-    Backwards x <|> Backwards y = Backwards (x <|> y)
-
--- | Derived instance.
-instance (Foldable f) => Foldable (Backwards f) where
-    foldMap f (Backwards t) = foldMap f t
-    foldr f z (Backwards t) = foldr f z t
-    foldl f z (Backwards t) = foldl f z t
-    foldr1 f (Backwards t) = foldl1 f t
-    foldl1 f (Backwards t) = foldr1 f t
-
--- | Derived instance.
-instance (Traversable f) => Traversable (Backwards f) where
-    traverse f (Backwards t) = fmap Backwards (traverse f t)
-    sequenceA (Backwards t) = fmap Backwards (sequenceA t)
diff --git a/compat/Control/Applicative/Lift.hs b/compat/Control/Applicative/Lift.hs
deleted file mode 100644
--- a/compat/Control/Applicative/Lift.hs
+++ /dev/null
@@ -1,71 +0,0 @@
--- |
--- Module      :  Control.Applicative.Lift
--- Copyright   :  (c) Ross Paterson 2010
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  ross@soi.city.ac.uk
--- Stability   :  experimental
--- Portability :  portable
---
--- Adding a new kind of pure computation to an applicative functor.
---
--- NB: This module is only included in @lens@ for backwards compatibility with
--- @transformers@ versions before 3.0.
-
-module Control.Applicative.Lift (
-    Lift(..), unLift,
-    -- * Collecting errors
-    Errors, failure
-  ) where
-
-import Control.Applicative
-import Data.Foldable (Foldable(foldMap))
-import Data.Functor.Constant
-import Data.Monoid
-import Data.Traversable (Traversable(traverse))
-
--- | Applicative functor formed by adding pure computations to a given
--- applicative functor.
-data Lift f a = Pure a | Other (f a)
-
-instance (Functor f) => Functor (Lift f) where
-    fmap f (Pure x) = Pure (f x)
-    fmap f (Other y) = Other (fmap f y)
-
-instance (Foldable f) => Foldable (Lift f) where
-    foldMap f (Pure x) = f x
-    foldMap f (Other y) = foldMap f y
-
-instance (Traversable f) => Traversable (Lift f) where
-    traverse f (Pure x) = Pure <$> f x
-    traverse f (Other y) = Other <$> traverse f y
-
--- | A combination is 'Pure' only if both parts are.
-instance (Applicative f) => Applicative (Lift f) where
-    pure = Pure
-    Pure f <*> Pure x = Pure (f x)
-    Pure f <*> Other y = Other (f <$> y)
-    Other f <*> Pure x = Other (($ x) <$> f)
-    Other f <*> Other y = Other (f <*> y)
-
--- | A combination is 'Pure' only either part is.
-instance Alternative f => Alternative (Lift f) where
-    empty = Other empty
-    Pure x <|> _ = Pure x
-    Other _ <|> Pure y = Pure y
-    Other x <|> Other y = Other (x <|> y)
-
--- | Projection to the other functor.
-unLift :: Applicative f => Lift f a -> f a
-unLift (Pure x) = pure x
-unLift (Other e) = e
-
--- | An applicative functor that collects a monoid (e.g. lists) of errors.
--- A sequence of computations fails if any of its components do, but
--- unlike monads made with 'ErrorT' from "Control.Monad.Trans.Error",
--- these computations continue after an error, collecting all the errors.
-type Errors e = Lift (Constant e)
-
--- | Report an error.
-failure :: Monoid e => e -> Errors e a
-failure e = Other (Constant e)
diff --git a/compat/Data/Functor/Reverse.hs b/compat/Data/Functor/Reverse.hs
deleted file mode 100644
--- a/compat/Data/Functor/Reverse.hs
+++ /dev/null
@@ -1,57 +0,0 @@
--- |
--- Module      :  Data.Functor.Reverse
--- Copyright   :  (c) Russell O'Connor 2009
--- License     :  BSD-style (see the file LICENSE)
---
--- Maintainer  :  libraries@haskell.org
--- Stability   :  experimental
--- Portability :  portable
---
--- Making functors whose elements are notionally in the reverse order
--- from the original functor.
---
--- /NB:/ Note this module is only included in @lens@ for backwards
--- compatibility with older @containers@ versions.
-
-module Data.Functor.Reverse where
-
-import Control.Applicative.Backwards
-
-import Prelude hiding (foldr, foldr1, foldl, foldl1)
-import Control.Applicative
-import Data.Foldable
-import Data.Traversable
-import Data.Monoid
-
--- | The same functor, but with 'Foldable' and 'Traversable' instances
--- that process the elements in the reverse order.
-newtype Reverse f a = Reverse { getReverse :: f a }
-
--- | Derived instance.
-instance (Functor f) => Functor (Reverse f) where
-    fmap f (Reverse a) = Reverse (fmap f a)
-
--- | Derived instance.
-instance (Applicative f) => Applicative (Reverse f) where
-    pure a = Reverse (pure a)
-    Reverse f <*> Reverse a = Reverse (f <*> a)
-
--- | Derived instance.
-instance (Alternative f) => Alternative (Reverse f) where
-    empty = Reverse empty
-    Reverse x <|> Reverse y = Reverse (x <|> y)
-
--- | Fold from right to left.
-instance (Foldable f) => Foldable (Reverse f) where
-    foldMap f (Reverse t) = getDual (foldMap (Dual . f) t)
-    foldr f z (Reverse t) = foldl (flip f) z t
-    foldl f z (Reverse t) = foldr (flip f) z t
-    foldr1 f (Reverse t) = foldl1 (flip f) t
-    foldl1 f (Reverse t) = foldr1 (flip f) t
-
--- | Traverse from right to left.
-instance (Traversable f) => Traversable (Reverse f) where
-    traverse f (Reverse t) =
-        fmap Reverse . forwards $ traverse (Backwards . f) t
-    sequenceA (Reverse t) =
-        fmap Reverse . forwards $ sequenceA (fmap Backwards t)
diff --git a/lens.cabal b/lens.cabal
--- a/lens.cabal
+++ b/lens.cabal
@@ -1,6 +1,6 @@
 name:          lens
 category:      Data, Lenses
-version:       3.7.2
+version:       3.7.3
 license:       BSD3
 cabal-version: >= 1.8
 license-file:  LICENSE
@@ -157,35 +157,35 @@
   default: True
   manual: True
 
-flag transformers2
+flag old-semigroups
   default: False
   manual: False
 
+
 library
   build-depends:
     base                 >= 4.3      && < 5,
     bytestring           >= 0.9.1.10 && < 0.11,
-    comonad              == 3.0.*,
-    comonad-transformers == 3.0.*,
-    comonads-fd          == 3.0.*,
+    comonad              >= 3,
+    comonad-transformers >= 3,
+    comonads-fd          >= 3,
     containers           >= 0.4.0    && < 0.6,
     hashable             >= 1.1.2.3  && < 1.3,
     mtl                  >= 2.0.1    && < 2.2,
-    semigroups           >= 0.8.4    && < 0.9,
     split                == 0.2.*,
     text                 >= 0.11     && < 0.12,
+    transformers         >= 0.2      && < 0.4,
+    transformers-compat  >= 0.1,
     unordered-containers >= 0.2      && < 0.3,
     vector               >= 0.9      && < 0.11
 
-  if flag(transformers2)
-    build-depends:  transformers >= 0.2 && < 0.3
-    hs-source-dirs: compat
-    exposed-modules:
-      Control.Applicative.Backwards
-      Control.Applicative.Lift
-      Data.Functor.Reverse
+  if flag(old-semigroups)
+    build-depends:
+      semigroups >= 0.8.4 && < 0.9
   else
-    build-depends: transformers >= 0.3 && < 0.4
+    build-depends:
+      nats >= 0.1,
+      semigroups >= 0.9
 
   exposed-modules:
     Control.Exception.Lens