diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -1,1 +1,8 @@
 language: haskell
+# Use this when hackage is down.
+# before_install:
+#   - mkdir -p ~/.cabal
+#   - cp config ~/.cabal/config
+#   - cabal update
+notifications:
+  irc: "irc.freenode.org#haskell-lens"
diff --git a/lens.cabal b/lens.cabal
--- a/lens.cabal
+++ b/lens.cabal
@@ -1,6 +1,6 @@
 name:          lens
 category:      Data, Lenses
-version:       2.0
+version:       2.1
 license:       BSD3
 cabal-version: >= 1.8
 license-file:  LICENSE
@@ -33,7 +33,7 @@
   .
   The core of this hierarchy looks like:
   .
-  <<https://github.com/ekmett/lens/wiki/images/Hierarchy-2.0.png>>
+  <<https://github.com/ekmett/lens/wiki/images/Hierarchy-2.1.png>>
   .
   You can compose any two elements of the hierarchy above using (.) from the Prelude, and you can
   use any element of the hierarchy as any type it links to above it.
@@ -94,7 +94,7 @@
   build-depends:
     base             >= 4.3   && < 5,
     containers       >= 0.4.2 && < 0.6,
-    mtl              >= 2.0.1 && < 2.2,
+    mtl              >= 2.1.1 && < 2.2,
     template-haskell >= 2.4   && < 2.8,
     transformers     >= 0.3   && < 0.4
 
@@ -125,6 +125,7 @@
                    Data.IntMap.Lens
                    Data.IntSet.Lens
                    Data.Map.Lens
+                   Data.Monoid.Lens
                    Data.Sequence.Lens
                    Data.Set.Lens
                    Data.Tree.Lens
diff --git a/src/Control/Lens.hs b/src/Control/Lens.hs
--- a/src/Control/Lens.hs
+++ b/src/Control/Lens.hs
@@ -30,8 +30,8 @@
 -- @
 --
 -- You can then access the value with ('^.') and set the value of the field
--- with ('.~') and can use almost any other combinator that is re-exported here
--- on those fields.
+-- with ('.~') and can use almost any other combinator that is re-exported
+-- here on those fields.
 --
 -- The combinators here have unusually specific type signatures, so for
 -- particularly tricky ones, the simpler type signatures you might want to
diff --git a/src/Control/Lens/Fold.hs b/src/Control/Lens/Fold.hs
--- a/src/Control/Lens/Fold.hs
+++ b/src/Control/Lens/Fold.hs
@@ -13,18 +13,22 @@
 -- Stability   :  provisional
 -- Portability :  Rank2Types
 --
--- A @'Fold' a c@ is a generalization of something 'Foldable'. It allows you to
--- extract multiple results from a container. A 'Foldable' container can be
--- characterized by the behavior of @foldMap :: ('Foldable' t, 'Monoid' m) => (c -> m) -> t c -> m@.
--- Since we want to be able to work with monomorphic containers, we could generalize this signature to
--- @forall m. 'Monoid' m => (c -> m) -> a -> m@, and then decorate it with 'Accessor' to obtain
+-- A @'Fold' a c@ is a generalization of something 'Foldable'. It allows
+-- you to extract multiple results from a container. A 'Foldable' container
+-- can be characterized by the behavior of
+-- @foldMap :: ('Foldable' t, 'Monoid' m) => (c -> m) -> t c -> m@.
+-- Since we want to be able to work with monomorphic containers, we could
+-- generalize this signature to @forall m. 'Monoid' m => (c -> m) -> a -> m@,
+-- and then decorate it with 'Accessor' to obtain
 --
 -- @type 'Fold' a c = forall m. 'Monoid' m => 'Getting' m a c@
 --
--- Every 'Getter' is a valid 'Fold' that simply doesn't use the 'Monoid' it is passed.
+-- Every 'Getter' is a valid 'Fold' that simply doesn't use the 'Monoid'
+-- it is passed.
 --
--- But in practice the type we use is slightly more complicated to allow for better error messages
--- and for it to be transformed by certain 'Applicative' transformers.
+-- In practice the type we use is slightly more complicated to allow for
+-- better error messages and for it to be transformed by certain 
+-- 'Applicative' transformers.
 --
 -- Everything you can do with a 'Foldable' container, you can with with a 'Fold' and there are
 -- combinators that generalize the usual 'Foldable' operations here.
diff --git a/src/Control/Lens/Getter.hs b/src/Control/Lens/Getter.hs
--- a/src/Control/Lens/Getter.hs
+++ b/src/Control/Lens/Getter.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE Rank2Types #-}
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Getter
 -- Copyright   :  (C) 2012 Edward Kmett
@@ -9,27 +9,31 @@
 -- Portability :  Rank2Types
 --
 --
--- A @'Getter' a c@ is just any function @(a -> c)@, which we've flipped into continuation
--- passing style, @(c -> r) -> a -> r@ and decorated with 'Accessor' to obtain
+-- A @'Getter' a c@ is just any function @(a -> c)@, which we've flipped
+-- into continuation passing style, @(c -> r) -> a -> r@ and decorated
+-- with 'Accessor' to obtain:
 --
 -- @type 'Getting' r a c = (c -> 'Accessor' r c) -> a -> 'Accessor' r a@
 --
--- If we restrict access to knowledge about the type 'r' and can work for any d and b, we could get:
+-- If we restrict access to knowledge about the type 'r' and can work for
+-- any d and b, we could get:
 --
 -- @type 'Getter' a c = forall r. 'Getting' r a c@
 --
--- But we actually hide the use of 'Accessor' behind a class 'Gettable' to error messages from
--- type class resolution rather than at unification time, where they are much uglier.
+-- But we actually hide the use of 'Accessor' behind a class 'Gettable'
+-- to error messages from type class resolution rather than at unification
+-- time, where they are much uglier.
 --
 -- @type 'Getter' a c = forall f. 'Gettable' f => (c -> f c) -> a -> f a@
 --
--- Everything you can do with a function, you can do with a 'Getter', but note that because of the
--- continuation passing style ('.') composes them in the opposite order.
+-- Everything you can do with a function, you can do with a 'Getter', but
+-- note that because of the continuation passing style ('.') composes them
+-- in the opposite order.
 --
--- Since it is only a function, every 'Getter' obviously only retrieves a single value for a given
--- input.
+-- Since it is only a function, every 'Getter' obviously only retrieves a
+-- single value for a given input.
 --
-----------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 module Control.Lens.Getter
   (
   -- * Getters
@@ -60,17 +64,19 @@
 infixl 8 ^.
 infixr 0 ^$
 
----------------
+-------------------------------------------------------------------------------
 -- Getters
----------------
+-------------------------------------------------------------------------------
 
--- | A 'Getter' describes how to retrieve a single value in a way that can be composed with
--- other lens-like constructions.
+-- | A 'Getter' describes how to retrieve a single value in a way that can be
+-- composed with other lens-like constructions.
 --
--- Unlike a 'Control.Lens.Type.Lens' a 'Getter' is read-only. Since a 'Getter' cannot be used to write back
--- there are no lens laws that can be applied to it. In fact, it is isomorphic to an arbitrary function from @(a -> c)@.
+-- Unlike a 'Control.Lens.Type.Lens' a 'Getter' is read-only. Since a 'Getter'
+-- cannot be used to write back there are no lens laws that can be applied to
+-- it. In fact, it is isomorphic to an arbitrary function from @(a -> c)@.
 --
--- Moreover, a 'Getter' can be used directly as a 'Control.Lens.Fold.Fold', since it just ignores the 'Applicative'.
+-- Moreover, a 'Getter' can be used directly as a 'Control.Lens.Fold.Fold',
+-- since it just ignores the 'Applicative'.
 type Getter a c = forall f. Gettable f => (c -> f c) -> a -> f a
 
 -- | Build a 'Getter' from an arbitrary Haskell function.
@@ -87,24 +93,28 @@
 {-# INLINE to #-}
 
 -- |
--- Most 'Getter' combinators are able to be used with both a 'Getter' or a 'Control.Lens.Fold.Fold' in
--- limited situations, to do so, they need to be monomorphic in what we are going to
--- extract with 'Const'. To be compatible with 'Control.Lens.Type.Lens', 'Control.Lens.Traversal.Traversal' and 'Control.Lens.Iso.Iso' we also
--- restricted choices of the irrelevant b and d parameters.
+-- Most 'Getter' combinators are able to be used with both a 'Getter' or a
+-- 'Control.Lens.Fold.Fold' in limited situations, to do so, they need to be
+-- monomorphic in what we are going to extract with 'Const'. To be compatible
+-- with 'Control.Lens.Type.Lens', 'Control.Lens.Traversal.Traversal' and
+-- 'Control.Lens.Iso.Iso' we also restricted choices of the irrelevant @b@ and
+-- @d@ parameters.
 --
--- If a function accepts a @'Getting' r a c@, then when @r@ is a 'Monoid', then you can pass a 'Control.Lens.Fold.Fold' (or 'Control.Lens.Traversal.Traversal'), otherwise you can only pass this a
+-- If a function accepts a @'Getting' r a c@, then when @r@ is a 'Monoid', then
+-- you can pass a 'Control.Lens.Fold.Fold' (or
+-- 'Control.Lens.Traversal.Traversal'), otherwise you can only pass this a
 -- 'Getter' or 'Control.Lens.Type.Lens'.
 type Getting r a c = (c -> Accessor r c) -> a -> Accessor r a
 
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Gettables & Accessors
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
--- | Generalizing 'Const' so we can apply simple 'Applicative' transformations to it
--- and so we can get nicer error messages
+-- | Generalizing 'Const' so we can apply simple 'Applicative'
+-- transformations to it and so we can get nicer error messages
 --
--- A 'Gettable' 'Functor' ignores its argument, which it carries solely as a phantom
--- type parameter.
+-- A 'Gettable' 'Functor' ignores its argument, which it carries solely as a
+-- phantom type parameter.
 --
 -- To ensure this, an instance of 'Gettable' is required to satisfy:
 --
@@ -133,8 +143,8 @@
 --
 -- @No instance of ('Control.Lens.Setter.Settable' 'Accessor')@
 --
--- when the user attempts to misuse a 'Control.Lens.Setter.Setter' as a 'Getter',
--- rather than a monolithic unification error.
+-- when the user attempts to misuse a 'Control.Lens.Setter.Setter' as a
+-- 'Getter', rather than a monolithic unification error.
 newtype Accessor r a = Accessor { runAccessor :: r }
 
 instance Functor (Accessor r) where
@@ -147,14 +157,14 @@
   pure _ = Accessor mempty
   Accessor a <*> Accessor b = Accessor (mappend a b)
 
--------------------------------
+-------------------------------------------------------------------------------
 -- Getting Values
--------------------------------
+-------------------------------------------------------------------------------
 
--- | View the value pointed to by a 'Getter', 'Control.Lens.Iso.Iso' or 'Control.Lens.Type.Lens' or the result of folding over
--- all the results of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points at a monoidal values.
---
--- It may be useful to think of 'view' as having these more restrictive signatures:
+-- | View the value pointed to by a 'Getter', 'Control.Lens.Iso.Iso' or
+-- 'Control.Lens.Type.Lens' or the result of folding over all the results of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points
+-- at a monoidal values.
 --
 -- @'view' . 'to' = 'id'@
 --
@@ -162,6 +172,9 @@
 -- >>> view _2 (1,"hello")
 -- "hello"
 --
+-- It may be useful to think of 'view' as having these more restrictive
+-- signatures:
+--
 -- @
 -- view ::             'Getter' a c             -> a -> c
 -- view :: 'Monoid' m => 'Control.Lens.Fold.Fold' a m               -> a -> m
@@ -173,10 +186,13 @@
 view l = runAccessor . l Accessor
 {-# INLINE view #-}
 
--- | View the value of a 'Getter', 'Control.Lens.Iso.Iso', 'Control.Lens.Type.Lens' or the result of folding over the
--- result of mapping the targets of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal'.
+-- | View the value of a 'Getter', 'Control.Lens.Iso.Iso',
+-- 'Control.Lens.Type.Lens' or the result of folding over the result of mapping
+-- the targets of a 'Control.Lens.Fold.Fold' or
+-- 'Control.Lens.Traversal.Traversal'.
 --
--- It may be useful to think of 'views' as having these more restrictive signatures:
+-- It may be useful to think of 'views' as having these more restrictive
+-- signatures:
 --
 -- >>> import Control.Lens
 -- >>> views _2 length (1,"hello")
@@ -193,8 +209,10 @@
 views l f = runAccessor . l (Accessor . f)
 {-# INLINE views #-}
 
--- | View the value pointed to by a 'Getter', 'Control.Lens.Iso.Iso' or 'Control.Lens.Type.Lens' or the result of folding over
--- all the results of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points at a monoidal values.
+-- | View the value pointed to by a 'Getter', 'Control.Lens.Iso.Iso' or
+-- 'Control.Lens.Type.Lens' or the result of folding over all the results of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points
+-- at a monoidal values.
 --
 -- This is the same operation as 'view', only infix.
 --
@@ -213,8 +231,9 @@
 l ^$ a = runAccessor (l Accessor a)
 {-# INLINE (^$) #-}
 
--- | View the value pointed to by a 'Getter' or 'Control.Lens.Type.Lens' or the result of folding over
--- all the results of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points at a monoidal values.
+-- | View the value pointed to by a 'Getter' or 'Control.Lens.Type.Lens' or the
+-- result of folding over all the results of a 'Control.Lens.Fold.Fold' or
+-- 'Control.Lens.Traversal.Traversal' that points at a monoidal values.
 --
 -- This is the same operation as 'view' with the arguments flipped.
 --
@@ -236,13 +255,15 @@
 a ^. l = runAccessor (l Accessor a)
 {-# INLINE (^.) #-}
 
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- MonadReader
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 -- |
--- Query the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or 'Getter' in the current state, or use a
--- summary of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points to a monoidal value.
+-- Query the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or
+-- 'Getter' in the current state, or use a summary of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points
+-- to a monoidal value.
 --
 -- @
 -- query :: 'MonadReader' a m             => 'Getter' a c           -> m c
@@ -256,8 +277,10 @@
 {-# INLINE query #-}
 
 -- |
--- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or 'Getter' in the current state, or use a
--- summary of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points to a monoidal value.
+-- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or
+-- 'Getter' in the current state, or use a summary of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points
+-- to a monoidal value.
 --
 -- @
 -- queries :: 'MonadReader' a m             => 'Getter' a c           -> (c -> e) -> m e
@@ -270,13 +293,15 @@
 queries l f = Reader.asks (views l f)
 {-# INLINE queries #-}
 
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- MonadState
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 -- |
--- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso', or 'Getter' in the current state, or use a
--- summary of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points to a monoidal value.
+-- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso', or
+-- 'Getter' in the current state, or use a summary of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points
+-- to a monoidal value.
 --
 -- @
 -- use :: 'MonadState' a m             => 'Getter' a c             -> m c
@@ -290,8 +315,10 @@
 {-# INLINE use #-}
 
 -- |
--- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or 'Getter' in the current state, or use a
--- summary of a 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that points to a monoidal value.
+-- Use the target of a 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso' or
+-- 'Getter' in the current state, or use a summary of a
+-- 'Control.Lens.Fold.Fold' or 'Control.Lens.Traversal.Traversal' that
+-- points to a monoidal value.
 --
 -- @
 -- uses :: 'MonadState' a m             => 'Getter' a c           -> (c -> e) -> m e
diff --git a/src/Control/Lens/Iso.hs b/src/Control/Lens/Iso.hs
--- a/src/Control/Lens/Iso.hs
+++ b/src/Control/Lens/Iso.hs
@@ -12,21 +12,31 @@
 ----------------------------------------------------------------------------
 module Control.Lens.Iso
   (
-  -- * Isomorphisms
-    Isomorphic(..)
-  , Isomorphism(..)
+  -- * Isomorphism Lenses
+    Iso
   , iso
   , isos
-  , from
+  , au
+  , auf
+  , under
+  -- ** Combinators
   , via
-  , Iso
-  , SimpleIso
+  , from
+  -- ** Common Isomorphisms
   , _const
   , identity
+  -- * Implementation
+  , Isomorphic(..)
+  , Isomorphism(..)
+  -- * Simplicity
+  , SimpleIso
   ) where
 
 import Control.Applicative
 import Control.Category
+import Control.Lens.Type
+import Control.Lens.Getter
+import Control.Lens.Setter
 import Data.Functor.Identity
 import Data.Typeable
 import Prelude hiding ((.),id)
@@ -154,6 +164,35 @@
 {-# INLINE iso #-}
 {-# SPECIALIZE iso :: Functor f => (a -> b) -> (b -> a) -> (b -> f b) -> a -> f a #-}
 {-# SPECIALIZE iso :: Functor f => (a -> b) -> (b -> a) -> Isomorphism (b -> f b) (a -> f a) #-}
+
+-- | Based on @ala@ from Conor McBride's work on Epigram.
+--
+-- Mnemonically, /au/ is a French contraction of /à le/.
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _sum foldMap [1,2,3,4]
+-- 10
+au :: Simple Iso a b -> ((a -> b) -> c -> b) -> c -> a
+au l f e = f (view l) e ^. from l
+{-# INLINE au #-}
+
+-- |
+-- Based on @ala'@ from Conor McBride's work on Epigram.
+--
+-- Mnemonically, the German /auf/ plays a similar role to /à la/, and the combinator
+-- is /au/ with an extra function argument.
+auf :: Simple Iso a b -> ((d -> b) -> c -> b) -> (d -> a) -> c -> a
+auf l f g e = f (view l . g) e ^. from l
+{-# INLINE auf #-}
+
+-- | The opposite of working 'over' a Setter is working 'under' an Isomorphism.
+--
+-- @'under' = 'over' . 'from'@
+--
+-- @'under' :: Iso a b c d -> (a -> b) -> (c -> d)@
+under :: Isomorphism (c -> Mutator d) (a -> Mutator b) -> (a -> b) -> c -> d
+under = over . from
+{-# INLINE under #-}
 
 -----------------------------------------------------------------------------
 -- Isomorphisms
diff --git a/src/Control/Lens/Setter.hs b/src/Control/Lens/Setter.hs
--- a/src/Control/Lens/Setter.hs
+++ b/src/Control/Lens/Setter.hs
@@ -31,7 +31,7 @@
   -- * Common Setters
   , mapped
   -- * Functional Combinators
-  , adjust
+  , over
   , mapOf
   , set
   , (.~), (%~)
@@ -73,8 +73,8 @@
 -- However, two 'Functor' laws apply to a 'Setter':
 --
 -- @
--- 'adjust' l id = id
--- 'adjust' l f . 'adjust' l g = 'adjust' l (f . g)
+-- 'over' l 'id' = 'id'
+-- 'over' l f . 'over' l g = 'over' l (f . g)
 -- @
 --
 -- These an be stated more directly:
@@ -162,8 +162,8 @@
 -- | This setter can be used to map over all of the values in a 'Functor'.
 --
 -- @
--- 'fmap' = 'adjust' 'mapped'
--- 'Data.Traversable.fmapDefault' = 'adjust' 'Data.Traversable.traverse'
+-- 'fmap' = 'over' 'mapped'
+-- 'Data.Traversable.fmapDefault' = 'over' 'Data.Traversable.traverse'
 -- ('<$') = 'set' 'mapped'
 -- @
 mapped :: Functor f => Setter (f a) (f b) a b
@@ -182,8 +182,8 @@
 -- Equational reasoning:
 --
 -- @
--- 'sets' . 'adjust' = 'id'
--- 'adjust' . 'sets' = 'id'
+-- 'sets' . 'over' = 'id'
+-- 'over' . 'sets' = 'id'
 -- @
 --
 -- Another way to view 'sets' is that it takes a \"semantic editor combinator\"
@@ -200,25 +200,25 @@
 -- with a function.
 --
 -- @
--- 'fmap' = 'adjust' 'mapped'
--- 'Data.Traversable.fmapDefault' = 'adjust' 'Data.Traversable.traverse'
--- 'sets' . 'adjust' = 'id'
--- 'adjust' . 'sets' = 'id'
+-- 'fmap' = 'over' 'mapped'
+-- 'Data.Traversable.fmapDefault' = 'over' 'Data.Traversable.traverse'
+-- 'sets' . 'over' = 'id'
+-- 'over' . 'sets' = 'id'
 -- @
 --
--- Another way to view 'adjust' is to say that it transformers a 'Setter' into a
+-- Another way to view 'over' is to say that it transformers a 'Setter' into a
 -- \"semantic editor combinator\".
 --
--- @'adjust' :: 'Setter' a b c d -> (c -> d) -> a -> b@
-adjust :: Setting a b c d -> (c -> d) -> a -> b
-adjust l f = runMutator . l (Mutator . f)
-{-# INLINE adjust #-}
+-- @'over' :: 'Setter' a b c d -> (c -> d) -> a -> b@
+over :: Setting a b c d -> (c -> d) -> a -> b
+over l f = runMutator . l (Mutator . f)
+{-# INLINE over #-}
 
 -- | Modify the target of a 'Control.Lens.Type.Lens' or all the targets of a 'Setter' or 'Control.Lens.Traversal.Traversal'
--- with a function. This is an alias for adjust that is provided for consistency.
+-- with a function. This is an alias for 'over' that is provided for consistency.
 --
 -- @
--- 'mapOf' = 'adjust'
+-- 'mapOf' = 'over'
 -- 'fmap' = 'mapOf' 'mapped'
 -- 'fmapDefault' = 'mapOf' 'traverse'
 -- 'sets' . 'mapOf' = 'id'
@@ -232,7 +232,7 @@
 -- mapOf :: 'Control.Lens.Traversal.Traversal' a b c d   -> (c -> d) -> a -> b
 -- @
 mapOf :: Setting a b c d -> (c -> d) -> a -> b
-mapOf = adjust
+mapOf = over
 {-# INLINE mapOf #-}
 
 -- | Replace the target of a 'Control.Lens.Type.Lens' or all of the targets of a 'Setter'
@@ -263,7 +263,7 @@
 -- | Modifies the target of a 'Control.Lens.Type.Lens' or all of the targets of a 'Setter' or
 -- 'Control.Lens.Traversal.Traversal' with a user supplied function.
 --
--- This is an infix version of 'adjust'
+-- This is an infix version of 'over'
 --
 -- @
 -- 'fmap' f = 'mapped' '%~' f
@@ -281,7 +281,7 @@
 -- (%~) :: 'Control.Lens.Traversal.Traversal' a b c d -> (c -> d) -> a -> b
 -- @
 (%~) :: Setting a b c d -> (c -> d) -> a -> b
-(%~) = adjust
+(%~) = over
 {-# INLINE (%~) #-}
 
 -- | Replace the target of a 'Control.Lens.Type.Lens' or all of the targets of a 'Setter'
@@ -309,7 +309,7 @@
 --
 -- This is mostly present for consistency, but may be useful for for chaining assignments
 --
--- If you do not need a copy of the intermediate result, then using @l .~ d@ directly is a good idea.
+-- If you do not need a copy of the intermediate result, then using @l '.~' d@ directly is a good idea.
 --
 -- @
 -- (\<.~) :: 'Setter' a b c d    -> d -> a -> (d, b)
@@ -334,7 +334,7 @@
 -- (+~) :: Num c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (+~) :: Num c => Setting a b c c -> c -> a -> b
-l +~ n = adjust l (+ n)
+l +~ n = over l (+ n)
 {-# INLINE (+~) #-}
 
 -- | Multiply the target(s) of a numerically valued 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso', 'Setter' or 'Control.Lens.Traversal.Traversal'
@@ -350,7 +350,7 @@
 -- (*~) :: 'Num' c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (*~) :: Num c => Setting a b c c -> c -> a -> b
-l *~ n = adjust l (* n)
+l *~ n = over l (* n)
 {-# INLINE (*~) #-}
 
 -- | Decrement the target(s) of a numerically valued 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso', 'Setter' or 'Control.Lens.Traversal.Traversal'
@@ -366,7 +366,7 @@
 -- (-~) :: 'Num' c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (-~) :: Num c => Setting a b c c -> c -> a -> b
-l -~ n = adjust l (subtract n)
+l -~ n = over l (subtract n)
 {-# INLINE (-~) #-}
 
 -- | Divide the target(s) of a numerically valued 'Control.Lens.Type.Lens', 'Control.Lens.Iso.Iso', 'Setter' or 'Control.Lens.Traversal.Traversal'
@@ -378,7 +378,7 @@
 -- (//~) :: 'Fractional' c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (//~) :: Fractional c => Setting a b c c -> c -> a -> b
-l //~ n = adjust l (/ n)
+l //~ n = over l (/ n)
 
 -- | Raise the target(s) of a numerically valued 'Control.Lens.Type.Lens', 'Setter' or 'Control.Lens.Traversal.Traversal' to a non-negative integral power
 --
@@ -386,7 +386,7 @@
 -- >>> _2 ^~ 2 $ (1,3)
 -- (1,9)
 (^~) :: (Num c, Integral e) => Setting a b c c -> e -> a -> b
-l ^~ n = adjust l (^ n)
+l ^~ n = over l (^ n)
 {-# INLINE (^~) #-}
 
 -- | Raise the target(s) of a fractionally valued 'Control.Lens.Type.Lens', 'Setter' or 'Control.Lens.Traversal.Traversal' to an integral power
@@ -403,7 +403,7 @@
 -- @
 --
 (^^~) :: (Fractional c, Integral e) => Setting a b c c -> e -> a -> b
-l ^^~ n = adjust l (^^ n)
+l ^^~ n = over l (^^ n)
 {-# INLINE (^^~) #-}
 
 -- | Raise the target(s) of a floating-point valued 'Control.Lens.Type.Lens', 'Setter' or 'Control.Lens.Traversal.Traversal' to an arbitrary power.
@@ -419,7 +419,7 @@
 -- (**~) :: 'Floating' c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (**~) :: Floating c => Setting a b c c -> c -> a -> b
-l **~ n = adjust l (** n)
+l **~ n = over l (** n)
 {-# INLINE (**~) #-}
 
 -- | Logically '||' the target(s) of a 'Bool'-valued 'Control.Lens.Type.Lens' or 'Setter'
@@ -439,7 +439,7 @@
 -- (||~):: 'Control.Lens.Traversal.Traversal' a b 'Bool' 'Bool' -> 'Bool' -> a -> b
 -- @
 (||~):: Setting a b Bool Bool -> Bool -> a -> b
-l ||~ n = adjust l (|| n)
+l ||~ n = over l (|| n)
 {-# INLINE (||~) #-}
 
 -- | Logically '&&' the target(s) of a 'Bool'-valued 'Control.Lens.Type.Lens' or 'Setter'
@@ -459,7 +459,7 @@
 -- (&&~):: 'Control.Lens.Traversal.Traversal' a b 'Bool' 'Bool' -> 'Bool' -> a -> b
 -- @
 (&&~) :: Setting a b Bool Bool -> Bool -> a -> b
-l &&~ n = adjust l (&& n)
+l &&~ n = over l (&& n)
 {-# INLINE (&&~) #-}
 
 -- | Modify the target of a monoidally valued by 'mappend'ing another value.
@@ -475,7 +475,7 @@
 -- (<>~) :: 'Monoid' c => 'Control.Lens.Traversal.Traversal' a b c c -> c -> a -> b
 -- @
 (<>~) :: Monoid c => Setting a b c c -> c -> a -> b
-l <>~ n = adjust l (`mappend` n)
+l <>~ n = over l (`mappend` n)
 {-# INLINE (<>~) #-}
 
 ------------------------------------------------------------------------------
diff --git a/src/Control/Lens/Type.hs b/src/Control/Lens/Type.hs
--- a/src/Control/Lens/Type.hs
+++ b/src/Control/Lens/Type.hs
@@ -9,7 +9,7 @@
 #define MIN_VERSION_mtl(x,y,z) 1
 #endif
 
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Type
 -- Copyright   :  (C) 2012 Edward Kmett
@@ -20,31 +20,36 @@
 --
 -- A @'Lens' a b c d@ is a purely functional reference.
 --
--- While a 'Control.Lens.Traversal.Traversal' could be used for 'Control.Lens.Getter.Getting' like a valid 'Control.Lens.Fold.Fold',
--- it wasn't a valid 'Getter' as Applicative isn't a superclass of 
+-- While a 'Control.Lens.Traversal.Traversal' could be used for
+-- 'Control.Lens.Getter.Getting' like a valid 'Control.Lens.Fold.Fold',
+-- it wasn't a valid 'Getter' as Applicative isn't a superclass of
 -- 'Gettable'.
 --
 -- 'Functor', however is the superclass of both.
 --
 -- @type 'Lens' a b c d = forall f. 'Functor' f => (c -> f d) -> a -> f b@
 --
--- Every 'Lens' is a valid 'Setter', choosing @f@ = 'Control.Lens.Getter.Mutator'.
+-- Every 'Lens' is a valid 'Setter', choosing @f@ =
+-- 'Control.Lens.Getter.Mutator'.
 --
--- Every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a 'Control.Lens.Fold.Fold' that doesn't use
--- the 'Applicative' or 'Control.Lens.Getter.Gettable'.
+-- Every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a
+-- 'Control.Lens.Fold.Fold' that doesn't use the 'Applicative' or
+-- 'Control.Lens.Getter.Gettable'.
 --
--- Every 'Lens' is a valid 'Control.Lens.Traversal.Traversal' that only uses the 'Functor' part
--- of the 'Applicative' it is supplied.
+-- Every 'Lens' is a valid 'Control.Lens.Traversal.Traversal' that only uses
+-- the 'Functor' part of the 'Applicative' it is supplied.
 --
--- Every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a valid 'Getter', since 'Functor' is
--- a superclass of 'Control.Lens.Getter.Gettable'
+-- Every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a valid
+-- 'Getter', since 'Functor' is a superclass of 'Control.Lens.Getter.Gettable'
 --
--- Since every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a valid 'Getter' it
--- follows that it must view exactly one element in the structure.
+-- Since every 'Lens' can be used for 'Control.Lens.Getter.Getting' like a
+-- valid 'Getter' it follows that it must view exactly one element in the
+-- structure.
 --
 -- The lens laws follow from this property and the desire for it to act like
--- a 'Data.Traversable.Traversable' when used as a 'Control.Lens.Traversal.Traversal'.
-----------------------------------------------------------------------------
+-- a 'Data.Traversable.Traversable' when used as a
+-- 'Control.Lens.Traversal.Traversal'.
+-------------------------------------------------------------------------------
 module Control.Lens.Type
   (
   -- * Lenses
@@ -73,13 +78,17 @@
 
   -- * Lateral Composition
   , merged
-  , bothLenses
+  , alongside
 
   -- * Setting Functionally with Passthrough
-  , (<%~), (<+~), (<-~), (<*~), (<//~), (<^~), (<^^~), (<**~), (<||~), (<&&~), (<<>~)
+  , (<%~), (<+~), (<-~), (<*~), (<//~)
+  , (<^~), (<^^~), (<**~)
+  , (<||~), (<&&~), (<<>~)
 
   -- * Setting State with Passthrough
-  , (<%=), (<+=), (<-=), (<*=), (<//=), (<^=), (<^^=), (<**=), (<||=), (<&&=), (<<>=)
+  , (<%=), (<+=), (<-=), (<*=), (<//=)
+  , (<^=), (<^^=), (<**=)
+  , (<||=), (<&&=), (<<>=)
 
   -- * Cloning Lenses
   , clone
@@ -110,13 +119,15 @@
 infix  4 <+=, <*=, <-=, <//=, <^=, <^^=, <**=, <&&=, <||=, <%=, <<>=
 
 
---------------------------
+-------------------------------------------------------------------------------
 -- Lenses
---------------------------
+-------------------------------------------------------------------------------
 
--- | A 'Lens' is actually a lens family as described in <http://comonad.com/reader/2012/mirrored-lenses/>.
+-- | A 'Lens' is actually a lens family as described in
+-- <http://comonad.com/reader/2012/mirrored-lenses/>.
 --
--- With great power comes great responsibility and a 'Lens' is subject to the three common sense lens laws:
+-- With great power comes great responsibility and a 'Lens'is subject to the
+-- three common sense lens laws:
 --
 -- 1) You get back what you put in:
 --
@@ -130,14 +141,19 @@
 --
 -- @'set' l c ('set' l b a) = 'set' l c a@
 --
--- These laws are strong enough that the 4 type parameters of a 'Lens' cannot vary fully independently. For more on
--- how they interact, read the "Why is it a Lens Family?" section of <http://comonad.com/reader/2012/mirrored-lenses/>.
+-- These laws are strong enough that the 4 type parameters of a 'Lens' cannot
+-- vary fully independently. For more on how they interact, read the "Why is
+-- it a Lens Family?" section of
+-- <http://comonad.com/reader/2012/mirrored-lenses/>.
 --
--- Every 'Lens' can be used directly as a 'Setter' or 'Control.Lens.Traversal.Traversal'.
+-- Every 'Lens' can be used directly as a 'Setter' or
+-- 'Control.Lens.Traversal.Traversal'.
 --
--- You can also use a 'Lens' for 'Control.Lens.Getter.Getting' as if it were a 'Control.Lens.Fold.Fold' or 'Getter'.
+-- You can also use a 'Lens' for 'Control.Lens.Getter.Getting' as if it were a
+-- 'Control.Lens.Fold.Fold' or 'Getter'.
 --
--- Since every lens is a valid 'Control.Lens.Traversal.Traversal', the traversal laws should also apply to any lenses you create.
+-- Since every lens is a valid 'Control.Lens.Traversal.Traversal', the
+-- traversal laws should also apply to any lenses you create.
 --
 -- 1.) Idiomatic naturality:
 --
@@ -150,7 +166,8 @@
 -- @type 'Lens' a b c d = forall f. 'Functor' f => 'LensLike' f a b c d@
 type Lens a b c d = forall f. Functor f => (c -> f d) -> a -> f b
 
--- | A 'Simple' 'Lens', 'Simple' 'Control.Lens.Traversal.Traversal', ... can be used instead of a 'Lens','Control.Lens.Traversal.Traversal', ...
+-- | A 'Simple' 'Lens', 'Simple' 'Control.Lens.Traversal.Traversal', ... can
+-- be used instead of a 'Lens','Control.Lens.Traversal.Traversal', ...
 -- whenever the type variables don't change upon setting a value.
 --
 -- @
@@ -158,8 +175,8 @@
 -- 'Data.List.Lens.traverseHead' :: 'Simple' 'Control.Lens.Lens.Traversal' [a] a
 -- @
 --
--- Note: To use this alias in your own code with @'LensLike' f@ or 'Control.Lens.Setter.Setter', you may have to turn on
--- @LiberalTypeSynonyms@.
+-- Note: To use this alias in your own code with @'LensLike' f@ or
+-- 'Control.Lens.Setter.Setter', you may have to turn on @LiberalTypeSynonyms@.
 type Simple f a b = f a a b b
 
 -- | @type 'SimpleLens' = 'Simple' 'Lens'@
@@ -179,27 +196,32 @@
 lens ac adb cfd a = adb a <$> cfd (ac a)
 {-# INLINE lens #-}
 
---------------------------
+-------------------------------------------------------------------------------
 -- LensLike
---------------------------
+-------------------------------------------------------------------------------
 
 -- |
--- Many combinators that accept a 'Lens' can also accept a 'Control.Lens.Traversal.Traversal' in limited situations.
+-- Many combinators that accept a 'Lens' can also accept a
+-- 'Control.Lens.Traversal.Traversal' in limited situations.
 --
--- They do so by specializing the type of 'Functor' that they require of the caller.
+-- They do so by specializing the type of 'Functor' that they require of the
+-- caller.
 --
--- If a function accepts a @'LensLike' f a b c d@ for some 'Functor' @f@, then they may be passed a 'Lens'.
+-- If a function accepts a @'LensLike' f a b c d@ for some 'Functor' @f@,
+-- then they may be passed a 'Lens'.
 --
--- Further, if @f@ is an 'Applicative', they may also be passed a 'Control.Lens.Traversal.Traversal'.
+-- Further, if @f@ is an 'Applicative', they may also be passed a
+-- 'Control.Lens.Traversal.Traversal'.
 type LensLike f a b c d = (c -> f d) -> a -> f b
 
 -- | ('%%~') can be used in one of two scenarios:
 --
--- When applied to a 'Lens', it can edit the target of the 'Lens' in a structure, extracting a
--- functorial result.
+-- When applied to a 'Lens', it can edit the target of the 'Lens' in a
+-- structure, extracting a functorial result.
 --
--- When applied to a 'Control.Lens.Traversal.Traversal', it can edit the targets of the 'Traversals', extracting an
--- applicative summary of its actions.
+-- When applied to a 'Control.Lens.Traversal.Traversal', it can edit the
+-- targets of the 'Traversals', extracting an applicative summary of its
+-- actions.
 --
 -- For all that the definition of this combinator is just:
 --
@@ -211,10 +233,12 @@
 -- (%%~) :: 'Applicative' f => 'Control.Lens.Traversal.Traversal' a b c d -> (c -> f d) -> a -> f b
 -- @
 --
--- It may be beneficial to think about it as if it had these even more restrictive types, however:
+-- It may be beneficial to think about it as if it had these even more
+-- restrictive types, however:
 --
--- When applied to a 'Control.Lens.Traversal.Traversal', it can edit the targets of the 'Traversals', extracting a
--- supplemental monoidal summary of its actions, by choosing f = ((,) m)
+-- When applied to a 'Control.Lens.Traversal.Traversal', it can edit the
+-- targets of the 'Traversals', extracting a supplemental monoidal summary
+-- of its actions, by choosing @f = ((,) m)@
 --
 -- @
 -- (%%~) ::             'Control.Lens.Iso.Iso' a b c d       -> (c -> (e, d)) -> a -> (e, b)
@@ -225,14 +249,15 @@
 (%%~) = id
 {-# INLINE (%%~) #-}
 
--- | Modify the target of a 'Lens' in the current state returning some extra information of @c@ or
--- modify all targets of a 'Control.Lens.Traversal.Traversal' in the current state, extracting extra information of type @c@
--- and return a monoidal summary of the changes.
+-- | Modify the target of a 'Lens' in the current state returning some extra
+-- information of @c@ or modify all targets of a
+-- 'Control.Lens.Traversal.Traversal' in the current state, extracting extra
+-- information of type @c@ and return a monoidal summary of the changes.
 --
 -- @('%%=') = ('state' '.')@
 --
--- It may be useful to think of ('%%='), instead, as having either of the following more restricted
--- type signatures:
+-- It may be useful to think of ('%%='), instead, as having either of the
+-- following more restricted type signatures:
 --
 -- @
 -- (%%=) :: 'MonadState' a m             => 'Control.Lens.Iso.Iso' a a c d       -> (c -> (e, d) -> m e
@@ -250,15 +275,18 @@
 #endif
 {-# INLINE (%%=) #-}
 
--- | This class allows us to use 'focus' on a number of different monad transformers.
+-- | This class allows us to use 'focus' on a number of different monad
+-- transformers.
 class Focus st where
-  -- | Run a monadic action in a larger context than it was defined in, using a 'Simple' 'Lens' or 'Simple' 'Control.Lens.Traversal.Traversal'.
+  -- | Run a monadic action in a larger context than it was defined in,
+  -- using a 'Simple' 'Lens' or 'Simple' 'Control.Lens.Traversal.Traversal'.
   --
-  -- This is commonly used to lift actions in a simpler state monad into a state monad with a larger state type.
+  -- This is commonly used to lift actions in a simpler state monad into a
+  -- state monad with a larger state type.
   --
-  -- When applied to a 'Simple 'Control.Lens.Traversal.Traversal' over multiple values, the actions for each target are executed sequentially
-  -- and the results are aggregated monoidally
-  -- and a monoidal summary
+  -- When applied to a 'Simple 'Control.Lens.Traversal.Traversal' over
+  -- multiple values, the actions for each target are executed sequentially
+  -- and the results are aggregated monoidally and a monoidal summary
   -- of the result is given.
   --
   -- @
@@ -285,29 +313,39 @@
 {-# INLINE skip #-}
 
 instance Focus Strict.StateT where
-  focus l m = Strict.StateT $ unfocusing . l (Focusing . Strict.runStateT m)
+  focus l m = Strict.StateT $
+    unfocusing . l (Focusing . Strict.runStateT m)
   {-# INLINE focus #-}
-  focus_ l m = Strict.StateT $ unfocusing . l (Focusing . Strict.runStateT (liftM skip m))
+  focus_ l m = Strict.StateT $
+    unfocusing . l (Focusing . Strict.runStateT (liftM skip m))
   {-# INLINE focus_ #-}
-  setFocus l m = Strict.state $ (,) () . runIdentity . l (Identity . snd . Strict.runState m)
+  setFocus l m = Strict.state $
+    (,) () . runIdentity . l (Identity . snd . Strict.runState m)
 
 instance Focus Lazy.StateT where
-  focus l m = Lazy.StateT $ unfocusing . l (Focusing . Lazy.runStateT m)
+  focus l m = Lazy.StateT $
+    unfocusing . l (Focusing . Lazy.runStateT m)
   {-# INLINE focus #-}
-  focus_ l m = Lazy.StateT $ unfocusing . l (Focusing . Lazy.runStateT (liftM skip m))
+  focus_ l m = Lazy.StateT $
+    unfocusing . l (Focusing . Lazy.runStateT (liftM skip m))
   {-# INLINE focus_ #-}
-  setFocus l m = Lazy.state $ (,) () . runIdentity . l (Identity . snd . Lazy.runState m)
+  setFocus l m = Lazy.state $
+    (,) () . runIdentity . l (Identity . snd . Lazy.runState m)
+  {-# INLINE setFocus #-}
 
 instance Focus ReaderT where
-  focus l m = ReaderT $ liftM fst . unfocusing . l (\b -> Focusing $ (\c -> (c,b)) `liftM` runReaderT m b)
+  focus l m = ReaderT $
+    liftM fst . unfocusing . l (\b -> Focusing $
+      (\c -> (c,b)) `liftM` runReaderT m b)
   {-# INLINE focus #-}
-  focus_ l m = ReaderT $ \a -> liftM skip $ unfocusing $ l (\b -> Focusing $ (\_ -> ((),b)) `liftM` runReaderT m b) a
+  focus_ l m = ReaderT $ \a -> liftM skip $
+    unfocusing $ l (\b -> Focusing $ (\_ -> ((),b)) `liftM` runReaderT m b) a
   {-# INLINE focus_ #-}
   setFocus _ _ = return () -- BOOORING
 
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Common Lenses
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 {-
 -- | This is a lens that can change the value (and type) of the first field of
@@ -349,33 +387,38 @@
 {-# INLINE resultAt #-}
 
 -- | Merge two lenses, getters, setters, folds or traversals.
-merged :: Functor f => LensLike f a b c c -> LensLike f a' b' c c -> LensLike f (Either a a') (Either b b') c c
+merged :: Functor f
+       => LensLike f a b c c
+       -> LensLike f a' b' c c
+       -> LensLike f (Either a a') (Either b b') c c
 merged l _ f (Left a)   = Left <$> l f a
 merged _ r f (Right a') = Right <$> r f a'
 {-# INLINE merged #-}
 
--- | 'bothLenses' makes a 'Lens' from two other lenses (or isomorphisms)
-bothLenses :: Lens a b c d -> Lens a' b' c' d' -> Lens (a,a') (b,b') (c,c') (d,d')
-bothLenses l r f (a, a') = case l (IndexedStore id) a of
+-- | 'alongside' makes a 'Lens' from two other lenses (or isomorphisms)
+alongside :: Lens a b c d
+           -> Lens a' b' c' d'
+           -> Lens (a,a') (b,b') (c,c') (d,d')
+alongside l r f (a, a') = case l (IndexedStore id) a of
   IndexedStore db c -> case r (IndexedStore id) a' of
     IndexedStore db' c' -> (\(d,d') -> (db d, db' d')) <$> f (c,c')
-{-# INLINE bothLenses #-}
+{-# INLINE alongside #-}
 
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Cloning Lenses
-------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 -- |
 --
 -- Cloning a 'Lens' is one way to make sure you arent given
--- something weaker, such as a 'Control.Lens.Traversal.Traversal' and can be used
--- as a way to pass around lenses that have to be monomorphic in 'f'.
+-- something weaker, such as a 'Control.Lens.Traversal.Traversal' and can be
+-- used as a way to pass around lenses that have to be monomorphic in @f@.
 --
 -- Note: This only accepts a proper 'Lens', because 'IndexedStore' lacks its
 -- (admissable) 'Applicative' instance.
 --
--- \"Costate Comonad Coalgebra is equivalent of Java's member variable update technology for Haskell\"
--- -- \@PLT_Borat on Twitter
+-- \"Costate Comonad Coalgebra is equivalent of Java's member variable
+-- update technology for Haskell\" -- \@PLT_Borat on Twitter
 clone :: Functor f
       => LensLike (IndexedStore c d) a b c d
       -> (c -> f d) -> a -> f b
@@ -383,9 +426,9 @@
   IndexedStore db c -> db <$> cfd c
 {-# INLINE clone #-}
 
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Overloading function application
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 -- | @type 'LensLike' f a b c d = 'Overloaded' (->) f a b c d@
 type Overloaded k f a b c d = k (c -> f d) (a -> f b)
@@ -393,9 +436,9 @@
 -- | @type 'SimpleOverloaded' k f a b = 'Simple' ('Overloaded' k f) a b@
 type SimpleOverloaded k f a b = Overloaded k f a a b b
 
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Setting and Remembering
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
 -- | Modify the target of a 'Lens' and return the result
 --
@@ -420,7 +463,8 @@
 
 -- | Multiply the target of a numerically valued 'Lens' and return the result
 --
--- When you do not need the result of the multiplication, ('*~') is more flexible.
+-- When you do not need the result of the multiplication, ('*~') is more
+-- flexible.
 (<*~) :: Num c => LensLike ((,)c) a b c c -> c -> a -> (c, b)
 l <*~ c = l <%~ (* c)
 {-# INLINE (<*~) #-}
@@ -432,21 +476,24 @@
 l <//~ c = l <%~ (/ c)
 {-# INLINE (<//~) #-}
 
--- | Raise the target of a numerically valued 'Lens' to a non-negative 'Integral' power and return the result
+-- | Raise the target of a numerically valued 'Lens' to a non-negative
+-- 'Integral' power and return the result
 --
 -- When you do not need the result of the division, ('^~') is more flexible.
 (<^~) :: (Num c, Integral d) => LensLike ((,)c) a b c c -> d -> a -> (c, b)
 l <^~ d = l <%~ (^ d)
 {-# INLINE (<^~) #-}
 
--- | Raise the target of a fractionally valued 'Lens' to an 'Integral' power and return the result
+-- | Raise the target of a fractionally valued 'Lens' to an 'Integral' power 
+-- and return the result.
 --
 -- When you do not need the result of the division, ('^^~') is more flexible.
 (<^^~) :: (Fractional c, Integral d) => LensLike ((,)c) a b c c -> d -> a -> (c, b)
 l <^^~ d = l <%~ (^^ d)
 {-# INLINE (<^^~) #-}
 
--- | Raise the target of a floating-point valued 'Lens' to an arbitrary power and return the result
+-- | Raise the target of a floating-point valued 'Lens' to an arbitrary power
+-- and return the result.
 --
 -- When you do not need the result of the division, ('**~') is more flexible.
 (<**~) :: Floating c => LensLike ((,)c) a b c c -> c -> a -> (c, b)
@@ -467,88 +514,103 @@
 l <&&~ c = l <%~ (&& c)
 {-# INLINE (<&&~) #-}
 
--- | 'mappend' a monoidal value onto the end of the target of a 'Lens' and return the result
+-- | 'mappend' a monoidal value onto the end of the target of a 'Lens' and
+-- return the result
 --
 -- When you do not need the result of the operation, ('<>~') is more flexible.
 (<<>~) :: Monoid m => LensLike ((,)m) a b m m -> m -> a -> (m, b)
 l <<>~ m = l <%~ (`mappend` m)
 {-# INLINE (<<>~) #-}
 
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- Setting and Remembering State
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 
--- | Modify the target of a 'Lens' into your monad's state by a user supplied function and return the result.
+-- | Modify the target of a 'Lens' into your monad's state by a user supplied
+-- function and return the result.
 --
 -- When you do not need the result of the operation, ('%=') is more flexible.
 (<%=) :: MonadState a m => LensLike ((,)d) a a c d -> (c -> d) -> m d
 l <%= f = l %%= (\c -> let d = f c in (d,d))
 {-# INLINE (<%=) #-}
 
--- | Add to the target of a numerically valued 'Lens' into your monad's state and return the result.
+-- | Add to the target of a numerically valued 'Lens' into your monad's state
+-- and return the result.
 --
--- When you do not need the result of the multiplication, ('+=') is more flexible.
+-- When you do not need the result of the multiplication, ('+=') is more
+-- flexible.
 (<+=) :: (MonadState a m, Num b) => SimpleLensLike ((,)b) a b -> b -> m b
 l <+= b = l <%= (+ b)
 {-# INLINE (<+=) #-}
 
--- | Subtract from the target of a numerically valued 'Lens' into your monad's state and return the result.
+-- | Subtract from the target of a numerically valued 'Lens' into your monad's
+-- state and return the result.
 --
--- When you do not need the result of the multiplication, ('-=') is more flexible.
+-- When you do not need the result of the multiplication, ('-=') is more
+-- flexible.
 (<-=) :: (MonadState a m, Num b) => SimpleLensLike ((,)b) a b -> b -> m b
 l <-= b = l <%= subtract b
 {-# INLINE (<-=) #-}
 
--- | Multiply the target of a numerically valued 'Lens' into your monad's state and return the result.
+-- | Multiply the target of a numerically valued 'Lens' into your monad's
+-- state and return the result.
 --
--- When you do not need the result of the multiplication, ('*=') is more flexible.
+-- When you do not need the result of the multiplication, ('*=') is more
+-- flexible.
 (<*=) :: (MonadState a m, Num b) => SimpleLensLike ((,)b) a b -> b -> m b
 l <*= b = l <%= (* b)
 {-# INLINE (<*=) #-}
 
--- | Divide the target of a fractionally valued 'Lens' into your monad's state and return the result.
+-- | Divide the target of a fractionally valued 'Lens' into your monad's state
+-- and return the result.
 --
 -- When you do not need the result of the division, ('//=') is more flexible.
 (<//=) :: (MonadState a m, Fractional b) => SimpleLensLike ((,)b) a b -> b -> m b
 l <//= b = l <%= (/ b)
 {-# INLINE (<//=) #-}
 
--- | Raise the target of a numerically valued 'Lens' into your monad's state to a non-negative 'Integral' power and return the result
+-- | Raise the target of a numerically valued 'Lens' into your monad's state
+-- to a non-negative 'Integral' power and return the result.
 --
 -- When you do not need the result of the operation, ('**=') is more flexible.
 (<^=) :: (MonadState a m, Num b, Integral c) => SimpleLensLike ((,)b) a b -> c -> m b
 l <^= c = l <%= (^ c)
 {-# INLINE (<^=) #-}
 
--- | Raise the target of a fractionally valued 'Lens' into your monad's state to an 'Integral' power and return the result
+-- | Raise the target of a fractionally valued 'Lens' into your monad's state
+-- to an 'Integral' power and return the result.
 --
 -- When you do not need the result of the operation, ('^^=') is more flexible.
 (<^^=) :: (MonadState a m, Fractional b, Integral c) => SimpleLensLike ((,)b) a b -> c -> m b
 l <^^= c = l <%= (^^ c)
 {-# INLINE (<^^=) #-}
 
--- | Raise the target of a floating-point valued 'Lens' into your monad's state to an arbitrary power and return the result
+-- | Raise the target of a floating-point valued 'Lens' into your monad's
+-- state to an arbitrary power and return the result.
 --
 -- When you do not need the result of the operation, ('**=') is more flexible.
 (<**=) :: (MonadState a m, Floating b) => SimpleLensLike ((,)b) a b -> b -> m b
 l <**= b = l <%= (** b)
 {-# INLINE (<**=) #-}
 
--- | Logically '||' a Boolean valued 'Lens' into your monad's state and return the result
+-- | Logically '||' a Boolean valued 'Lens' into your monad's state and return
+-- the result.
 --
 -- When you do not need the result of the operation, ('||=') is more flexible.
 (<||=) :: MonadState a m => SimpleLensLike ((,)Bool) a Bool -> Bool -> m Bool
 l <||= b = l <%= (|| b)
 {-# INLINE (<||=) #-}
 
--- | Logically '&&' a Boolean valued 'Lens' into your monad's state and return the result
+-- | Logically '&&' a Boolean valued 'Lens' into your monad's state and return
+-- the result.
 --
 -- When you do not need the result of the operation, ('&&=') is more flexible.
 (<&&=) :: MonadState a m => SimpleLensLike ((,)Bool) a Bool -> Bool -> m Bool
 l <&&= b = l <%= (&& b)
 {-# INLINE (<&&=) #-}
 
--- | 'mappend' a monoidal value onto the end of the target of a 'Lens' into your monad's state and return the result
+-- | 'mappend' a monoidal value onto the end of the target of a 'Lens' into
+-- your monad's state and return the result.
 --
 -- When you do not need the result of the operation, ('<>=') is more flexible.
 (<<>=) :: (MonadState a m, Monoid r) => SimpleLensLike ((,)r) a r -> r -> m r
diff --git a/src/Control/Parallel/Strategies/Lens.hs b/src/Control/Parallel/Strategies/Lens.hs
--- a/src/Control/Parallel/Strategies/Lens.hs
+++ b/src/Control/Parallel/Strategies/Lens.hs
@@ -25,14 +25,14 @@
 -- according to the given strategy.
 --
 -- @
--- 'evalTraversable' = 'evalTraversal' 'traverse' = 'traverse'
--- 'evalTraversal' = 'id'
+-- 'evalTraversable' = 'evalOf' 'traverse' = 'traverse'
+-- 'evalOf' = 'id'
 -- @
 --
 -- @
--- evalTraversal :: 'Simple' 'Lens' a b -> 'Strategy' b -> 'Strategy' a
--- evalTraversal :: 'Simple' 'Traversal' a b -> 'Strategy' b -> 'Strategy' a
--- evalTraversal :: (b -> 'Eval' b) -> a -> 'Eval' a) -> 'Strategy' b -> 'Strategy' a
+-- evalOf :: 'Simple' 'Lens' a b -> 'Strategy' b -> 'Strategy' a
+-- evalOf :: 'Simple' 'Traversal' a b -> 'Strategy' b -> 'Strategy' a
+-- evalOf :: (b -> 'Eval' b) -> a -> 'Eval' a) -> 'Strategy' b -> 'Strategy' a
 -- @
 evalOf :: SimpleLensLike Eval a b -> Strategy b -> Strategy a
 evalOf l = l
@@ -40,12 +40,12 @@
 -- | Evaluate the targets of a 'Lens' or 'Traversal' according into a
 -- data structure according to a given 'Strategy' in parallel.
 --
--- @'parTraversable' = 'parTraversal' 'traverse'@
+-- @'parTraversable' = 'parOf' 'traverse'@
 --
 -- @
--- parTraversal :: 'Simple' 'Lens' a b -> 'Strategy' b -> 'Strategy' a
--- parTraversal :: 'Simple' 'Traversal' a b -> 'Strategy' b -> 'Strategy' a
--- parTraversal :: ((b -> 'Eval' b) -> a -> 'Eval' a) -> 'Strategy' b -> 'Strategy' a
+-- parOf :: 'Simple' 'Lens' a b -> 'Strategy' b -> 'Strategy' a
+-- parOf :: 'Simple' 'Traversal' a b -> 'Strategy' b -> 'Strategy' a
+-- parOf :: ((b -> 'Eval' b) -> a -> 'Eval' a) -> 'Strategy' b -> 'Strategy' a
 -- @
 parOf :: SimpleLensLike Eval a b -> Strategy b -> Strategy a
 parOf l s = l (rparWith s)
diff --git a/src/Control/Seq/Lens.hs b/src/Control/Seq/Lens.hs
--- a/src/Control/Seq/Lens.hs
+++ b/src/Control/Seq/Lens.hs
@@ -19,6 +19,6 @@
 -- | Evaluate the elements targeted by a 'Lens', 'Traversal', 'Iso',
 -- 'Getter' or 'Fold' according to the given strategy.
 --
--- > seqFoldable = seqOf folded
+-- @'seqFoldable' = 'seqOf' 'folded'@
 seqOf :: Getting [c] a c -> Strategy c -> Strategy a
 seqOf l s = seqList s . toListOf l
diff --git a/src/Data/Array/Lens.hs b/src/Data/Array/Lens.hs
--- a/src/Data/Array/Lens.hs
+++ b/src/Data/Array/Lens.hs
@@ -44,13 +44,13 @@
 --
 -- This is a /contravariant/ 'Setter'.
 --
--- @'ixmap' = 'adjust' . 'ixmapped'@
+-- @'ixmap' = 'over' . 'ixmapped'@
 --
 -- @'ixmapped' = 'sets' . 'ixmap'@
 --
--- @'adjust' ('ixmapped' b) f arr '!' i = arr '!' f i@
+-- @'over' ('ixmapped' b) f arr '!' i = arr '!' f i@
 --
--- @'bounds' ('adjust' ('ixmapped' b) f arr) = b@
+-- @'bounds' ('over' ('ixmapped' b) f arr) = b@
 ixmapped :: (IArray a e, Ix i, Ix j) => (i,i) -> Setter (a j e) (a i e) i j
 ixmapped = sets . ixmap
 {-# INLINE ixmapped #-}
@@ -58,7 +58,7 @@
 -- | An 'IndexedTraversal' of the elements of an 'IArray', using the 
 -- index into the array as the index of the traversal.
 --
--- @'amap' = 'adjust' 'traverseArray'@
+-- @'amap' = 'over' 'traverseArray'@
 traverseArray :: (IArray a c, IArray a d, Ix i) => IndexedTraversal i (a i c) (a i d) c d
 traverseArray = index $ \f arr -> array (bounds arr) <$> traverse (\(i,a) -> (,) i <$> f i a) (assocs arr)
 {-# INLINE traverseArray #-}
diff --git a/src/Data/Bits/Lens.hs b/src/Data/Bits/Lens.hs
--- a/src/Data/Bits/Lens.hs
+++ b/src/Data/Bits/Lens.hs
@@ -30,7 +30,7 @@
 -- >>> _2 |~ 6 $ ("hello",3)
 -- ("hello",7)
 (|~):: Bits c => Setting a b c c -> c -> a -> b
-l |~ n = adjust l (.|. n)
+l |~ n = over l (.|. n)
 {-# INLINE (|~) #-}
 
 -- | Bitwise '.&.' the target(s) of a 'Bool'-valued 'Lens' or 'Setter'
@@ -38,7 +38,7 @@
 -- >>> _2 &~ 7 $ ("hello",254)
 -- ("hello",6)
 (&~) :: Bits c => Setting a b c c -> c -> a -> b
-l &~ n = adjust l (.&. n)
+l &~ n = over l (.&. n)
 {-# INLINE (&~) #-}
 
 -- | Modify the target(s) of a 'Simple' 'Lens', 'Setter' or 'Traversal' by computing its bitwise '.&.' with another value.
diff --git a/src/Data/Either/Lens.hs b/src/Data/Either/Lens.hs
--- a/src/Data/Either/Lens.hs
+++ b/src/Data/Either/Lens.hs
@@ -1,5 +1,5 @@
 {-# LANGUAGE LiberalTypeSynonyms #-}
------------------------------------------------------------------------------
+-------------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Either.Lens
 -- Copyright   :  (C) 2012 Edward Kmett
@@ -9,7 +9,7 @@
 -- Portability :  portable
 --
 -- Lenses for working with sums
-----------------------------------------------------------------------------
+------------------------------------------------------------------------------
 module Data.Either.Lens
   ( traverseLeft
   , traverseRight
@@ -18,22 +18,23 @@
 import Control.Applicative
 import Control.Lens
 
--- | A traversal for tweaking the left-hand value in an Either:
+-- | A traversal for tweaking the left-hand value of an 'Either':
 --
--- > traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f (Either b c)
+-- @traverseLeft :: 'Applicative' f => (a -> f b) -> 'Either' a c -> f ('Either' b c)@
 traverseLeft :: Traversal (Either a c) (Either b c) a b
 traverseLeft f (Left a)  = Left <$> f a
 traverseLeft _ (Right c) = pure $ Right c
 {-# INLINE traverseLeft #-}
 
--- | traverse the right-hand value in an Either:
+-- | traverse the right-hand value of an 'Either':
 --
--- > traverseRight = traverse
+-- @'traverseRight' = 'Data.Traversable.traverse'@
 --
--- Unfortunately the instance for 'Traversable (Either c)' is still missing
--- from base, so this can't just be 'traverse'
+-- Unfortunately the instance for
+-- @'Data.Traversable.Traversable' ('Either' c)@ is still missing from base,
+-- so this can't just be 'Data.Traversable.traverse'
 --
--- > traverseRight :: Applicative f => (a -> f b) -> Either c a -> f (Either c a)
+-- @traverseRight :: 'Applicative' f => (a -> f b) -> 'Either' c a -> f ('Either' c a)@
 traverseRight :: Traversal (Either c a) (Either c b) a b
 traverseRight _ (Left c) = pure $ Left c
 traverseRight f (Right a) = Right <$> f a
diff --git a/src/Data/IntSet/Lens.hs b/src/Data/IntSet/Lens.hs
--- a/src/Data/IntSet/Lens.hs
+++ b/src/Data/IntSet/Lens.hs
@@ -45,7 +45,7 @@
 -- elements might change but you can manipulate it by reading using 'folded' and
 -- reindexing it via 'setmap'.
 --
--- >>> adjust setmapped (+1) (fromList [1,2,3,4])
+-- >>> over setmapped (+1) (fromList [1,2,3,4])
 -- fromList [2,3,4,5]
 setmapped :: Simple Setter IntSet Int
 setmapped = sets IntSet.map
diff --git a/src/Data/Monoid/Lens.hs b/src/Data/Monoid/Lens.hs
new file mode 100644
--- /dev/null
+++ b/src/Data/Monoid/Lens.hs
@@ -0,0 +1,96 @@
+-----------------------------------------------------------------------------
+-- |
+-- Module      :  Data.Monoid.Lens
+-- Copyright   :  (C) 2012 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  Rank2Types
+--
+----------------------------------------------------------------------------
+module Data.Monoid.Lens
+  ( _dual, _endo, _all, _any, _sum, _product, _first, _last
+  ) where
+
+import Data.Monoid
+import Control.Lens
+
+-- | Isomorphism for 'Dual'
+_dual :: Iso a b (Dual a) (Dual b)
+_dual = isos Dual getDual Dual getDual
+{-# INLINE _dual #-}
+{-# SPECIALIZE _dual :: Functor f => Isomorphism (Dual a -> f (Dual b)) (a -> f b) #-}
+{-# SPECIALIZE _dual :: Functor f => (Dual a -> f (Dual b)) -> a -> f b #-}
+
+-- | Isomorphism for 'Endo'
+_endo :: Iso (a -> a) (b -> b) (Endo a) (Endo b)
+_endo = isos Endo appEndo Endo appEndo
+{-# INLINE _endo #-}
+{-# SPECIALIZE _endo :: Functor f => Isomorphism (Endo a -> f (Endo b)) ((a -> a) -> f (b -> b)) #-}
+{-# SPECIALIZE _endo :: Functor f => (Endo a -> f (Endo b)) -> (a -> a) -> f (b -> b) #-}
+
+-- | Isomorphism for 'All'
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _all foldMap [True,True]
+-- True
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _all foldMap [True,False]
+-- False
+_all :: Simple Iso Bool All
+_all = iso All getAll
+{-# INLINE _all #-}
+{-# SPECIALIZE _all :: Functor f => Isomorphism (All -> f All) (Bool -> f Bool) #-}
+{-# SPECIALIZE _all :: Functor f => (All -> f All) -> Bool -> f Bool #-}
+
+-- | Isomorphism for 'Any'
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _any foldMap [False,False]
+-- False
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _any foldMap [True,False]
+-- True
+_any :: Simple Iso Bool Any
+_any = iso Any getAny
+{-# INLINE _any #-}
+{-# SPECIALIZE _any :: Functor f => Isomorphism (Any -> f Any) (Bool -> f Bool) #-}
+{-# SPECIALIZE _any :: Functor f => (Any -> f Any) -> Bool -> f Bool #-}
+
+-- | Isomorphism for 'Sum'
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _sum foldMap [1,2,3,4]
+-- 10
+_sum :: Iso a b (Sum a) (Sum b)
+_sum = isos Sum getSum Sum getSum
+{-# INLINE _sum #-}
+{-# SPECIALIZE _sum :: Functor f => Isomorphism (Sum a -> f (Sum b)) (a -> f b) #-}
+{-# SPECIALIZE _sum :: Functor f => (Sum a -> f (Sum b)) -> a -> f b #-}
+
+-- | Isomorphism for 'Product'
+--
+-- >>> :m + Control.Lens Data.Monoid.Lens Data.Foldable
+-- >>> au _product foldMap [1,2,3,4]
+-- 24
+_product :: Iso a b (Product a) (Product b)
+_product = isos Product getProduct Product getProduct
+{-# INLINE _product #-}
+{-# SPECIALIZE _product :: Functor f => Isomorphism (Product a -> f (Product b)) (a -> f b) #-}
+{-# SPECIALIZE _product :: Functor f => (Product a -> f (Product b)) -> a -> f b #-}
+
+-- | Isomorphism for 'First'
+_first :: Iso (Maybe a) (Maybe b) (First a) (First b)
+_first = isos First getFirst First getFirst
+{-# INLINE _first #-}
+{-# SPECIALIZE _first :: Functor f => Isomorphism (First a -> f (First b)) (Maybe a -> f (Maybe b)) #-}
+{-# SPECIALIZE _first :: Functor f => (First a -> f (First b)) -> Maybe a -> f (Maybe b) #-}
+
+-- | Isomorphism for 'Last'
+_last :: Iso (Maybe a) (Maybe b) (Last a) (Last b)
+_last = isos Last getLast Last getLast
+{-# INLINE _last #-}
+{-# SPECIALIZE _last :: Functor f => Isomorphism (Last a -> f (Last b)) (Maybe a -> f (Maybe b)) #-}
+{-# SPECIALIZE _last :: Functor f => (Last a -> f (Last b)) -> Maybe a -> f (Maybe b) #-}
diff --git a/src/Data/Set/Lens.hs b/src/Data/Set/Lens.hs
--- a/src/Data/Set/Lens.hs
+++ b/src/Data/Set/Lens.hs
@@ -40,7 +40,7 @@
 -- manipulate it by reading using 'folded' and reindexing it via 'setmap'.
 --
 -- >>> :m + Data.Set.Lens Control.Lens
--- >>> adjust setmapped (+1) (fromList [1,2,3,4])
+-- >>> over setmapped (+1) (fromList [1,2,3,4])
 -- fromList [2,3,4,5]
 setmapped :: (Ord i, Ord j) => Setter (Set i) (Set j) i j
 setmapped = sets Set.map