diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,6 +1,20 @@
-4.7.0.1 [maintenance release]
+4.8
 ---
-* `primitive` 0.6 support
+* When built with `profunctors` 4.4 on GHC 7.8+ we no longer need to use `unsafeCoerce` at all!
+  This drastically reduces the level of trust involved in the way we have optimized `lens`.
+* Added `fusing`. This optimizes long `Lens` chains, by enfocing a form of `fmap` fusion based on the Yoneda lemma. This is particularly effective at making faster lenses the definition is recursive or complex enough that it cannot be inlined.
+* Added `confusing`. This optimizes long `Traversal` chains. As with `fusing` it is best used when the definition for the `Traversal` chain in question is recursive or complex enough that it cannot be inlined, but the implementation is much more confusing.
+* Remove deprecated stuff: `Control.Lens.Loupe`, `headOf`, `makeFieldsWith`,
+  `strippingPrefix`, `strippingSuffix`
+* Added `Cons` and `Snoc` instances for `NonEmpty`
+* Removed `Data.List.Split.Lens` module
+* Reimplemented `bytestring` traversals to avoid internal modules
+* Added `gplate`, an implementation of `plate` for any type implementing `Generic`
+* Strictness revisited
+  * Add `generateLazyPatterns` configuration flag to `makeLenses` rules.
+  * Make the default `makeLenses` behavior to generate STRICT optics
+  * Add strict variants of `_1` .. `_9` named `_1'` .. `_9'`
+* Generalized some combinators in `Data.Vector.Generic.Lens` and added `converted`
 
 4.7
 ---
diff --git a/LICENSE b/LICENSE
--- a/LICENSE
+++ b/LICENSE
@@ -1,4 +1,4 @@
-Copyright 2012-2014 Edward Kmett
+Copyright 2012-2015 Edward Kmett
 
 All rights reserved.
 
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -14,7 +14,8 @@
 Field Guide
 -----------
 
-[![Lens Hierarchy](https://s3.amazonaws.com/creately-published/h5nyo9ne1)](https://creately.com/diagram/h5nyo9ne1/LBbRz63yg4yQsTXGLtub1bQU4%3D)
+[![Lens Hierarchy](https://raw.githubusercontent.com/wiki/ekmett/lens/images/Hierarchy.png)](https://creately.com/diagram/h5nyo9ne1/QZ9UBOtw4AJWtmAKYK3wT8Mm1HM%3D)
+
 
 Examples
 --------
diff --git a/images/Hierarchy.png b/images/Hierarchy.png
Binary files a/images/Hierarchy.png and b/images/Hierarchy.png differ
diff --git a/lens-properties/src/Control/Lens/Properties.hs b/lens-properties/src/Control/Lens/Properties.hs
--- a/lens-properties/src/Control/Lens/Properties.hs
+++ b/lens-properties/src/Control/Lens/Properties.hs
@@ -27,7 +27,7 @@
 --
 -- 3. @over l f . over l g ≡ over l (f . g)@
 isSetter :: (Arbitrary s, Arbitrary a, CoArbitrary a, Show s, Show a, Eq s, Function a)
-         => Simple Setter s a -> Property
+         => Setter' s a -> Property
 isSetter l = setter_id l .&. setter_composition l .&. setter_set_set l
 
 
@@ -39,7 +39,7 @@
 --
 -- 2. @fmap (t f) . t g ≡ getCompose . t (Compose . fmap f . g)@
 isTraversal :: (Arbitrary s, Arbitrary a, CoArbitrary a, Show s, Show a, Eq s, Function a)
-         => Simple Traversal s a -> Property
+         => Traversal' s a -> Property
 isTraversal l = isSetter l .&. traverse_pureMaybe l .&. traverse_pureList l
                   .&. do as <- arbitrary
                          bs <- arbitrary
@@ -58,50 +58,50 @@
 --
 -- 3. @set l c (set l b a) ≡ set l c a@
 isLens :: (Arbitrary s, Arbitrary a, CoArbitrary a, Show s, Show a, Eq s, Eq a, Function a)
-       => Simple Lens s a -> Property
+       => Lens' s a -> Property
 isLens l = lens_set_view l .&. lens_view_set l .&. isTraversal l
 
 
 --------------------------------------------------------------------------------
 isIso :: (Arbitrary s, Arbitrary a, CoArbitrary s, CoArbitrary a, Show s, Show a, Eq s, Eq a, Function s, Function a)
-      => Simple Iso s a -> Property
+      => Iso' s a -> Property
 isIso l = iso_hither l .&. iso_yon l .&. isLens l .&. isLens (from l)
 
 
 --------------------------------------------------------------------------------
 isPrism :: (Arbitrary s, Arbitrary a, CoArbitrary a, Show s, Show a, Eq s, Eq a, Function a)
-      => Simple Prism s a -> Property
+      => Prism' s a -> Property
 isPrism l = isTraversal l .&. prism_yin l .&. prism_yang l
 
 
 --------------------------------------------------------------------------------
 -- The first setter law:
-setter_id :: Eq s => Simple Setter s a -> s -> Bool
+setter_id :: Eq s => Setter' s a -> s -> Bool
 setter_id l s = over l id s == s
 
 --  The second setter law:
-setter_composition :: Eq s => Simple Setter s a -> s -> Fun a a -> Fun a a -> Bool
+setter_composition :: Eq s => Setter' s a -> s -> Fun a a -> Fun a a -> Bool
 setter_composition l s (Fun _ f) (Fun _ g) = over l f (over l g s) == over l (f . g) s
 
-lens_set_view :: Eq s => Simple Lens s a -> s -> Bool
+lens_set_view :: Eq s => Lens' s a -> s -> Bool
 lens_set_view l s = set l (view l s) s == s
 
-lens_view_set :: Eq a => Simple Lens s a -> s -> a -> Bool
+lens_view_set :: Eq a => Lens' s a -> s -> a -> Bool
 lens_view_set l s a = view l (set l a s) == a
 
-setter_set_set :: Eq s => Simple Setter s a -> s -> a -> a -> Bool
+setter_set_set :: Eq s => Setter' s a -> s -> a -> a -> Bool
 setter_set_set l s a b = set l b (set l a s) == set l b s
 
-iso_hither :: Eq s => Simple AnIso s a -> s -> Bool
+iso_hither :: Eq s => AnIso' s a -> s -> Bool
 iso_hither l s = s ^.cloneIso l.from l == s
 
-iso_yon :: Eq a => Simple AnIso s a -> a -> Bool
+iso_yon :: Eq a => AnIso' s a -> a -> Bool
 iso_yon l a = a^.from l.cloneIso l == a
 
-prism_yin :: Eq a => Simple Prism s a -> a -> Bool
+prism_yin :: Eq a => Prism' s a -> a -> Bool
 prism_yin l a = preview l (review l a) == Just a
 
-prism_yang :: Eq s => Simple Prism s a -> s -> Bool
+prism_yang :: Eq s => Prism' s a -> s -> Bool
 prism_yang l s = maybe s (review l) (preview l s) == s
 
 traverse_pure :: forall f s a. (Applicative f, Eq (f s)) => LensLike' f s a -> s -> Bool
@@ -114,5 +114,5 @@
 traverse_pureList = traverse_pure
 
 traverse_compose :: (Applicative f, Applicative g, Eq (f (g s)))
-                    => Simple Traversal s a -> (a -> g a) -> (a -> f a) -> s -> Bool
+                    => Traversal' s a -> (a -> g a) -> (a -> f a) -> s -> Bool
 traverse_compose t f g s = (fmap (t f) . t g) s == (getCompose . t (Compose . fmap f . g)) s
diff --git a/lens.cabal b/lens.cabal
--- a/lens.cabal
+++ b/lens.cabal
@@ -1,6 +1,6 @@
 name:          lens
 category:      Data, Lenses, Generics
-version:       4.7.0.1
+version:       4.8
 license:       BSD3
 cabal-version: >= 1.8
 license-file:  LICENSE
@@ -9,7 +9,7 @@
 stability:     provisional
 homepage:      http://github.com/ekmett/lens/
 bug-reports:   http://github.com/ekmett/lens/issues
-copyright:     Copyright (C) 2012-2014 Edward A. Kmett
+copyright:     Copyright (C) 2012-2015 Edward A. Kmett
 build-type:    Custom
 -- build-tools:   cpphs
 tested-with:   GHC == 7.4.1, GHC == 7.4.2, GHC == 7.6.3, GHC == 7.8.1, GHC == 7.8.2
@@ -41,7 +41,7 @@
   With some signatures simplified, the core of the hierarchy of lens-like constructions looks like:
   .
   .
-  <<http://i.imgur.com/4fHw3Fd.png>>
+  <<http://i.imgur.com/ALlbPRa.png>>
   .
   <Hierarchy.png (Local Copy)>
   .
@@ -182,7 +182,7 @@
 library
   build-depends:
     array                     >= 0.3.0.2  && < 0.6,
-    base                      >= 4.3      && < 5,
+    base                      >= 4.5      && < 5,
     bifunctors                >= 4        && < 5,
     bytestring                >= 0.9.1.10 && < 0.11,
     comonad                   >= 4        && < 5,
@@ -193,20 +193,20 @@
     free                      >= 4        && < 5,
     ghc-prim,
     hashable                  >= 1.1.2.3  && < 1.3,
+    kan-extensions            >= 4.2.1    && < 5,
     exceptions                >= 0.1.1    && < 1,
     mtl                       >= 2.0.1    && < 2.3,
     parallel                  >= 3.1.0.1  && < 3.3,
-    primitive                 >= 0.4.0.1  && < 0.7,
+    primitive                 >= 0.4.0.1  && < 0.6,
     profunctors               >= 4        && < 5,
     reflection                >= 1.1.6    && < 2,
     semigroupoids             >= 4        && < 5,
     semigroups                >= 0.8.4    && < 1,
-    split                     >= 0.2      && < 0.3,
     tagged                    >= 0.4.4    && < 1,
     template-haskell          >= 2.4      && < 2.11,
     text                      >= 0.11     && < 1.3,
     transformers              >= 0.2      && < 0.5,
-    transformers-compat       >= 0.3      && < 1,
+    transformers-compat       >= 0.4      && < 1,
     unordered-containers      >= 0.2      && < 0.3,
     vector                    >= 0.9      && < 0.11,
     void                      >= 0.5      && < 1
@@ -227,6 +227,7 @@
     Control.Lens.Internal
     Control.Lens.Internal.Bazaar
     Control.Lens.Internal.ByteString
+    Control.Lens.Internal.Coerce
     Control.Lens.Internal.Context
     Control.Lens.Internal.Deque
     Control.Lens.Internal.Exception
@@ -238,6 +239,7 @@
     Control.Lens.Internal.Instances
     Control.Lens.Internal.Iso
     Control.Lens.Internal.Level
+    Control.Lens.Internal.List
     Control.Lens.Internal.Magma
     Control.Lens.Internal.Prism
     Control.Lens.Internal.Reflection
@@ -248,7 +250,6 @@
     Control.Lens.Iso
     Control.Lens.Lens
     Control.Lens.Level
-    Control.Lens.Loupe
     Control.Lens.Operators
     Control.Lens.Plated
     Control.Lens.Prism
@@ -276,7 +277,6 @@
     Data.HashSet.Lens
     Data.IntSet.Lens
     Data.List.Lens
-    Data.List.Split.Lens
     Data.Map.Lens
     Data.Sequence.Lens
     Data.Set.Lens
@@ -401,7 +401,6 @@
       parallel,
       semigroups     >= 0.9,
       simple-reflect >= 0.3.1,
-      split,
       text,
       unordered-containers,
       vector
diff --git a/src/Control/Exception/Lens.hs b/src/Control/Exception/Lens.hs
--- a/src/Control/Exception/Lens.hs
+++ b/src/Control/Exception/Lens.hs
@@ -22,7 +22,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Exception.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -146,7 +146,7 @@
 -- Catching
 ------------------------------------------------------------------------------
 
--- | Catch exceptions that match a given 'Prism' (or any 'Getter', really).
+-- | Catch exceptions that match a given 'Prism' (or any 'Fold', really).
 --
 -- >>> catching _AssertionFailed (assert False (return "uncaught")) $ \ _ -> return "caught"
 -- "caught"
@@ -227,7 +227,7 @@
 -- Trying
 ------------------------------------------------------------------------------
 
--- | A variant of 'Control.Exception.try' that takes a 'Prism' (or any 'Getter') to select which
+-- | A variant of 'Control.Exception.try' that takes a 'Prism' (or any 'Fold') to select which
 -- exceptions are caught (c.f. 'Control.Exception.tryJust', 'Control.Exception.catchJust'). If the
 -- 'Exception' does not match the predicate, it is re-thrown.
 --
diff --git a/src/Control/Lens.hs b/src/Control/Lens.hs
--- a/src/Control/Lens.hs
+++ b/src/Control/Lens.hs
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -55,7 +55,6 @@
   , module Control.Lens.Iso
   , module Control.Lens.Lens
   , module Control.Lens.Level
-  , module Control.Lens.Loupe
   , module Control.Lens.Plated
   , module Control.Lens.Prism
   , module Control.Lens.Reified
@@ -82,7 +81,6 @@
 import Control.Lens.Iso
 import Control.Lens.Lens
 import Control.Lens.Level
-import Control.Lens.Loupe
 import Control.Lens.Plated
 import Control.Lens.Prism
 import Control.Lens.Reified
diff --git a/src/Control/Lens/At.hs b/src/Control/Lens/At.hs
--- a/src/Control/Lens/At.hs
+++ b/src/Control/Lens/At.hs
@@ -20,7 +20,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.At
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Combinators.hs b/src/Control/Lens/Combinators.hs
--- a/src/Control/Lens/Combinators.hs
+++ b/src/Control/Lens/Combinators.hs
@@ -1,7 +1,7 @@
 --------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Combinators
--- Copyright   :  (C) 2013-14 Edward Kmett
+-- Copyright   :  (C) 2013-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Cons.hs b/src/Control/Lens/Cons.hs
--- a/src/Control/Lens/Cons.hs
+++ b/src/Control/Lens/Cons.hs
@@ -1,4 +1,5 @@
 {-# LANGUAGE CPP #-}
+{-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
@@ -9,7 +10,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Cons
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -40,6 +41,8 @@
 import Control.Lens.Type
 import qualified Data.ByteString      as StrictB
 import qualified Data.ByteString.Lazy as LazyB
+import           Data.List.NonEmpty   (NonEmpty(..))
+import qualified Data.List.NonEmpty   as NonEmpty
 import           Data.Monoid
 import qualified Data.Sequence as Seq
 import           Data.Sequence hiding ((<|), (|>))
@@ -94,6 +97,12 @@
     []     -> Left  []
   {-# INLINE _Cons #-}
 
+instance a~b => Cons (NonEmpty a) (NonEmpty b) a b where
+  _Cons = prism' (uncurry NonEmpty.cons) $ \ xyz -> case xyz of
+    (x:|y:z) -> Just (x,y:|z)
+    _        -> Nothing
+  {-# INLINE _Cons #-}
+
 instance Cons (Seq a) (Seq b) a b where
   _Cons = prism (uncurry (Seq.<|)) $ \aas -> case viewl aas of
     a :< as -> Right (a, as)
@@ -318,6 +327,12 @@
     then Left []
     else Right (Prelude.init aas, Prelude.last aas)
   {-# INLINE _Snoc #-}
+
+instance a~b => Snoc (NonEmpty a) (NonEmpty b) a b where
+  _Snoc = prism' (\(x:|y,z) -> x:|y++[z]) $ \xyz -> case xyz of
+    x:|y
+      | Prelude.null y -> Nothing
+      | otherwise      -> Just (x :| Prelude.init y, Prelude.last y)
 
 instance Snoc (Seq a) (Seq b) a b where
   _Snoc = prism (uncurry (Seq.|>)) $ \aas -> case viewr aas of
diff --git a/src/Control/Lens/Each.hs b/src/Control/Lens/Each.hs
--- a/src/Control/Lens/Each.hs
+++ b/src/Control/Lens/Each.hs
@@ -10,14 +10,10 @@
 #ifdef TRUSTWORTHY
 {-# LANGUAGE Trustworthy #-}
 #endif
-
-#ifndef MIN_VERSION_base
-#define MIN_VERSION_base(x,y,z) 1
-#endif
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Each
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -124,17 +120,10 @@
   each f ~(a,b,c,d,e,g,h,i,j) = (,,,,,,,,) <$> f a <*> f b <*> f c <*> f d <*> f e <*> f g <*> f h <*> f i <*> f j
   {-# INLINE each #-}
 
-#if MIN_VERSION_base(4,4,0)
 -- | @'each' :: ('RealFloat' a, 'RealFloat' b) => 'Traversal' ('Complex' a) ('Complex' b) a b@
 instance Each (Complex a) (Complex b) a b where
   each f (a :+ b) = (:+) <$> f a <*> f b
   {-# INLINE each #-}
-#else
--- | @'each' :: 'Traversal' ('Complex' a) ('Complex' b) a b@
-instance (RealFloat a, RealFloat b) => Each (Complex a) (Complex b) a b where
-  each f (a :+ b) = (:+) <$> f a <*> f b
-  {-# INLINE each #-}
-#endif
 
 -- | @'each' :: 'Traversal' ('Map' c a) ('Map' c b) a b@
 instance (c ~ d) => Each (Map c a) (Map d b) a b
diff --git a/src/Control/Lens/Empty.hs b/src/Control/Lens/Empty.hs
--- a/src/Control/Lens/Empty.hs
+++ b/src/Control/Lens/Empty.hs
@@ -8,7 +8,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Empty
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Equality.hs b/src/Control/Lens/Equality.hs
--- a/src/Control/Lens/Equality.hs
+++ b/src/Control/Lens/Equality.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Equality
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Extras.hs b/src/Control/Lens/Extras.hs
--- a/src/Control/Lens/Extras.hs
+++ b/src/Control/Lens/Extras.hs
@@ -1,7 +1,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.List.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
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
@@ -11,7 +11,7 @@
 ----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Fold
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -122,9 +122,6 @@
   , itakingWhile
   , idroppingWhile
 
-  -- * Deprecated
-  , headOf
-
   -- * Internal types
   , Leftmost
   , Rightmost
@@ -236,7 +233,11 @@
 --
 -- >>> timingOut $ 5^..taking 20 repeated
 -- [5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5,5]
-repeated :: Fold1 a a
+--
+-- @
+-- 'repeated' :: 'Fold1' a a
+-- @
+repeated :: Apply f => LensLike' f a a
 repeated f a = as where as = f a .> as
 {-# INLINE repeated #-}
 
@@ -259,7 +260,11 @@
 --
 -- >>> timingOut $ [1,2,3]^..taking 7 (cycled traverse)
 -- [1,2,3,1,2,3,1]
-cycled :: (Contravariant f, Apply f) => LensLike f s t a b -> LensLike f s t a b
+--
+-- @
+-- 'cycled' :: 'Fold1' s a -> 'Fold1' s a
+-- @
+cycled :: Apply f => LensLike f s t a b -> LensLike f s t a b
 cycled l f a = as where as = l f a .> as
 {-# INLINE cycled #-}
 
@@ -283,7 +288,11 @@
 -- @
 -- 'toListOf' ('iterated' f) a ≡ 'iterate' f a
 -- @
-iterated :: (a -> a) -> Fold1 a a
+--
+-- @
+-- 'iterated' :: (a -> a) -> 'Fold1' a a
+-- @
+iterated :: Apply f => (a -> a) -> LensLike' f a a
 iterated f g a0 = go a0 where
   go a = g a .> go (f a)
 {-# INLINE iterated #-}
@@ -1689,12 +1698,12 @@
 -- exists, as a 'Maybe'.
 --
 -- @
--- 'pre' :: 'Getter' s a           -> 'IndexPreservingGetter' s ('Maybe' a)
--- 'pre' :: 'Fold' s a             -> 'IndexPreservingGetter' s ('Maybe' a)
--- 'pre' :: 'Simple' 'Traversal' s a -> 'IndexPreservingGetter' s ('Maybe' a)
--- 'pre' :: 'Simple' 'Lens' s a      -> 'IndexPreservingGetter' s ('Maybe' a)
--- 'pre' :: 'Simple' 'Iso' s a       -> 'IndexPreservingGetter' s ('Maybe' a)
--- 'pre' :: 'Simple' 'Prism' s a     -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Getter' s a     -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Fold' s a       -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Traversal'' s a -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Lens'' s a      -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Iso'' s a       -> 'IndexPreservingGetter' s ('Maybe' a)
+-- 'pre' :: 'Prism'' s a     -> 'IndexPreservingGetter' s ('Maybe' a)
 -- @
 pre :: Getting (First a) s a -> IndexPreservingGetter s (Maybe a)
 pre l = dimap (getFirst . getConst #. l (Const #. First #. Just)) coerce
@@ -1704,10 +1713,10 @@
 -- and element, if they exist, as a 'Maybe'.
 --
 -- @
--- 'ipre' :: 'IndexedGetter' i s a             -> 'IndexPreservingGetter' s ('Maybe' (i, a))
--- 'ipre' :: 'IndexedFold' i s a               -> 'IndexPreservingGetter' s ('Maybe' (i, a))
--- 'ipre' :: 'Simple' ('IndexedTraversal' i) s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
--- 'ipre' :: 'Simple' ('IndexedLens' i) s a      -> 'IndexPreservingGetter' s ('Maybe' (i, a))
+-- 'ipre' :: 'IndexedGetter' i s a     -> 'IndexPreservingGetter' s ('Maybe' (i, a))
+-- 'ipre' :: 'IndexedFold' i s a       -> 'IndexPreservingGetter' s ('Maybe' (i, a))
+-- 'ipre' :: 'IndexedTraversal'' i s a -> 'IndexPreservingGetter' s ('Maybe' (i, a))
+-- 'ipre' :: 'IndexedLens'' i s a      -> 'IndexPreservingGetter' s ('Maybe' (i, a))
 -- @
 ipre :: IndexedGetting i (First (i, a)) s a -> IndexPreservingGetter s (Maybe (i, a))
 ipre l = dimap (getFirst . getConst #. l (Indexed $ \i a -> Const (First (Just (i, a))))) coerce
@@ -2389,16 +2398,6 @@
       b' = b && p i a
     in (if b' then pure a else indexed f i a, b')
 {-# INLINE idroppingWhile #-}
-
-------------------------------------------------------------------------------
--- Deprecated
-------------------------------------------------------------------------------
-
--- | A deprecated alias for 'firstOf'.
-headOf :: Getting (First a) s a -> s -> Maybe a
-headOf l = getFirst #. foldMapOf l (First #. Just)
-{-# INLINE headOf #-}
-{-# DEPRECATED headOf "`headOf' will be removed after GHC 7.8 is released. (Use `preview' or `firstOf')" #-}
 
 ------------------------------------------------------------------------------
 -- Misc.
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
@@ -12,7 +12,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Getter
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -51,6 +51,8 @@
   -- * Building Getters
   , to
   , ito
+  , like
+  , ilike
   -- * Combinators for Getters and Folds
   , (^.)
   , view, views
@@ -131,6 +133,33 @@
 ito k = dimap k (contramap (snd . k)) . uncurry . indexed
 {-# INLINE ito #-}
 
+
+-- | Build an constant-valued (index-preserving) 'Getter' from an arbitrary Haskell value.
+--
+-- @
+-- 'like' a '.' 'like' b ≡ 'like' b
+-- a '^.' 'like' b ≡ b
+-- a '^.' 'like' b ≡ a '^.' 'to' ('const' b)
+-- @
+--
+-- This can be useful as a second case 'failing' a 'Fold'
+-- e.g. @foo `failing` 'like' 0@
+--
+-- @
+-- 'like' :: a -> 'IndexPreservingGetter' s a
+-- @
+like :: (Profunctor p, Contravariant f) => a -> Optical' p p f s a
+like a = to (const a)
+{-# INLINE like #-}
+
+-- |
+-- @
+-- 'ilike' :: i -> a -> 'IndexedGetter' i s a
+-- @
+ilike :: (Indexable i p, Contravariant f) => i -> a -> Optical' p (->) f s a
+ilike i a = ito (const (i, a))
+{-# INLINE ilike #-}
+
 -- | When you see this in a type signature it indicates that you can
 -- pass the function a 'Lens', 'Getter',
 -- 'Control.Lens.Traversal.Traversal', 'Control.Lens.Fold.Fold',
@@ -455,7 +484,7 @@
 s ^@. l = getConst $ l (Indexed $ \i -> Const #. (,) i) s
 {-# INLINE (^@.) #-}
 
--- | Coerce a 'Getter'-compatible 'LensLike' to a 'Simple' 'LensLike'. This
+-- | Coerce a 'Getter'-compatible 'LensLike' to a 'LensLike''. This
 -- is useful when using a 'Traversal' that is not simple as a 'Getter' or a
 -- 'Fold'.
 coerced :: (Functor f, Contravariant f) => LensLike f s t a b -> LensLike' f s a
diff --git a/src/Control/Lens/Indexed.hs b/src/Control/Lens/Indexed.hs
--- a/src/Control/Lens/Indexed.hs
+++ b/src/Control/Lens/Indexed.hs
@@ -18,7 +18,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Indexed
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -264,7 +264,7 @@
 
   -- | The 'IndexedFold' of a 'FoldableWithIndex' container.
   --
-  -- 'ifolded'.'asIndex' is a fold over the keys of a 'FoldableWithIndex'.
+  -- @'ifolded' '.' 'asIndex'@ is a fold over the keys of a 'FoldableWithIndex'.
   --
   -- >>> Data.Map.fromList [(2, "hello"), (1, "world")]^..ifolded.asIndex
   -- [1,2]
diff --git a/src/Control/Lens/Internal.hs b/src/Control/Lens/Internal.hs
--- a/src/Control/Lens/Internal.hs
+++ b/src/Control/Lens/Internal.hs
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Bazaar.hs b/src/Control/Lens/Internal/Bazaar.hs
--- a/src/Control/Lens/Internal/Bazaar.hs
+++ b/src/Control/Lens/Internal/Bazaar.hs
@@ -13,7 +13,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Bazaar
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/ByteString.hs b/src/Control/Lens/Internal/ByteString.hs
--- a/src/Control/Lens/Internal/ByteString.hs
+++ b/src/Control/Lens/Internal/ByteString.hs
@@ -6,16 +6,19 @@
 #ifdef TRUSTWORTHY
 {-# LANGUAGE Trustworthy #-}
 #endif
+
 #ifndef MIN_VERSION_base
 #define MIN_VERSION_base(x,y,z) 1
 #endif
 
-{-# OPTIONS_GHC -fno-warn-deprecations #-} -- for inlinePerformIO
+#ifndef MIN_VERSION_bytestring
+#define MIN_VERSION_bytestring(x,y,z) 1
+#endif
 
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.ByteString.Strict.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -26,8 +29,8 @@
 -- Haskell Platforms and to improve constant and asymptotic factors in our performance.
 ----------------------------------------------------------------------------
 module Control.Lens.Internal.ByteString
-  ( unpackStrict, traversedStrict, traversedStrictTree
-  , unpackStrict8, traversedStrict8, traversedStrictTree8
+  ( unpackStrict, traversedStrictTree
+  , unpackStrict8, traversedStrictTree8
   , unpackLazy, traversedLazy
   , unpackLazy8, traversedLazy8
   ) where
@@ -35,10 +38,13 @@
 import Control.Applicative
 import Control.Lens
 import qualified Data.ByteString               as B
+#if MIN_VERSION_bytestring(0,10,4)
+import qualified Data.ByteString.Char8         as B8
+#endif
 import qualified Data.ByteString.Lazy          as BL
-import qualified Data.ByteString.Lazy.Internal as BLI
 import qualified Data.ByteString.Lazy.Char8    as BL8
 import qualified Data.ByteString.Internal      as BI
+import qualified Data.ByteString.Unsafe        as BU
 import Data.Bits
 import Data.Char
 import Data.Int (Int64)
@@ -47,10 +53,11 @@
 import Foreign.Storable
 #if MIN_VERSION_base(4,8,0)
 import Foreign.ForeignPtr
-import Foreign.ForeignPtr.Unsafe
 #elif MIN_VERSION_base(4,4,0)
 import Foreign.ForeignPtr.Safe
-import Foreign.ForeignPtr.Unsafe
+#if !MIN_VERSION_bytestring(0,10,4)
+import Foreign.ForeignPtr.Unsafe (unsafeForeignPtrToPtr)
+#endif
 #else
 import Foreign.ForeignPtr
 #endif
@@ -58,84 +65,42 @@
 import GHC.ForeignPtr (mallocPlainForeignPtrBytes)
 import GHC.IO (unsafeDupablePerformIO)
 
--- | Traverse a strict 'B.ByteString' from left to right in a biased fashion.
-traversedStrict :: Int -> IndexedTraversal' Int B.ByteString Word8
-traversedStrict i0 pafb (BI.PS fp off len) =
-  let p = unsafeForeignPtrToPtr fp
-   in fmap (rebuild len) (go i0 (p `plusPtr` off) (p `plusPtr` (off+len)))
- where
-   rebuild n = \xs -> unsafeCreate n $ \p -> go2 p xs
-   go2 !p (x:xs) = poke p x >> go2 (p `plusPtr` 1) xs
-   go2 _  []     = return ()
-   -- TODO: use a balanced tree (up to some grain size)
-   go !i !p !q
-     | p == q = pure []
-     | otherwise = let !x = BI.inlinePerformIO $ do
-                              x' <- peek p
-                              touchForeignPtr fp
-                              return x'
-                   in (:) <$> indexed pafb (i :: Int) x <*> go (i + 1) (p `plusPtr` 1) q
-{-# INLINE traversedStrict #-}
-
--- | Traverse a strict 'B.ByteString' from left to right in a biased fashion
--- pretending the bytes are characters.
-traversedStrict8 :: Int -> IndexedTraversal' Int B.ByteString Char
-traversedStrict8 i0 pafb (BI.PS fp off len) =
-  let p = unsafeForeignPtrToPtr fp
-   in fmap (rebuild len) (go i0 (p `plusPtr` off) (p `plusPtr` (off+len)))
- where
-   rebuild n = \xs -> unsafeCreate n $ \p -> go2 p xs
-   go2 !p (x:xs) = poke p (c2w x) >> go2 (p `plusPtr` 1) xs
-   go2 _  []     = return ()
-   -- TODO: use a balanced tree (up to some grain size)
-   go !i !p !q
-     | p == q = pure []
-     | otherwise = let !x = BI.inlinePerformIO $ do
-                              x' <- peek p
-                              touchForeignPtr fp
-                              return x'
-                   in (:) <$> indexed pafb (i :: Int) (w2c x) <*> go (i + 1) (p `plusPtr` 1) q
-{-# INLINE traversedStrict8 #-}
-
 grain :: Int
 grain = 32
 {-# INLINE grain #-}
 
 -- | Traverse a strict 'B.ByteString' in a relatively balanced fashion, as a balanced tree with biased runs of
 -- elements at the leaves.
-traversedStrictTree :: Int -> IndexedTraversal' Int B.ByteString Word8
-traversedStrictTree i0 pafb (BI.PS fp off len) = rebuild len <$> go (unsafeForeignPtrToPtr fp `plusPtr` (off - i0)) i0 (i0 + len)
+traversedStrictTree :: IndexedTraversal' Int B.ByteString Word8
+traversedStrictTree pafb bs = unsafeCreate len <$> go 0 len
  where
-   rebuild n f = unsafeCreate n $ \q -> f $! (q `plusPtr` (off - i0))
-   go !p !i !j
-     | i + grain < j, k <- i + shiftR (j - i) 1 = (\l r q -> l q >> r q) <$> go p i k <*> go p k j
-     | otherwise = run p i j
-   run !p !i !j
+   len = B.length bs
+   go !i !j
+     | i + grain < j, k <- i + shiftR (j - i) 1 = (\l r q -> l q >> r q) <$> go i k <*> go k j
+     | otherwise = run i j
+   run !i !j
      | i == j    = pure (\_ -> return ())
-     | otherwise = let !x = BI.inlinePerformIO $ do
-                          x' <- peekByteOff p i
-                          touchForeignPtr fp
-                          return x'
-                   in (\y ys !q -> pokeByteOff q i y >> ys q) <$> indexed pafb (i :: Int) x <*> run p (i + 1) j
+     | otherwise = let !x = BU.unsafeIndex bs i
+                   in (\y ys q -> pokeByteOff q i y >> ys q) <$> indexed pafb (i :: Int) x <*> run (i + 1) j
 {-# INLINE traversedStrictTree #-}
 
+
 -- | Traverse a strict 'B.ByteString' in a relatively balanced fashion, as a balanced tree with biased runs of
 -- elements at the leaves, pretending the bytes are chars.
-traversedStrictTree8 :: Int -> IndexedTraversal' Int B.ByteString Char
-traversedStrictTree8 i0 pafb (BI.PS fp off len) = rebuild len <$> go i0 (i0 + len)
+traversedStrictTree8 :: IndexedTraversal' Int B.ByteString Char
+traversedStrictTree8 pafb bs = unsafeCreate len <$> go 0 len
  where
-   p = unsafeForeignPtrToPtr fp `plusPtr` (off - i0)
-   rebuild n f = unsafeCreate n $ \q -> f (q `plusPtr` (off - i0))
+   len = B.length bs
    go !i !j
-     | i + grain < j, k <- i + shiftR (j - i) 1 = (\l r q -> l q >> r q) <$> go i k <*> go k j
-     | otherwise = run i j
+     | i + grain < j    = let k = i + shiftR (j - i) 1
+                          in (\l r q -> l q >> r q) <$> go i k <*> go k j
+     | otherwise        = run i j
    run !i !j
-     | i == j    = pure (\_ -> return ())
-     | otherwise = let !x = BI.inlinePerformIO $ do
-                          x' <- peekByteOff p i
-                          touchForeignPtr fp
-                          return x'
-                   in (\y ys q -> poke (q `plusPtr` i) (c2w y) >> ys q) <$> indexed pafb (i :: Int) (w2c x) <*> run (i + 1) j
+     | i == j           = pure (\_ -> return ())
+     | otherwise        = let !x = BU.unsafeIndex bs i
+                          in (\y ys q -> pokeByteOff q i (c2w y) >> ys q)
+                         <$> indexed pafb (i :: Int) (w2c x)
+                         <*> run (i + 1) j
 {-# INLINE traversedStrictTree8 #-}
 
 -- | Unpack a lazy 'Bytestring'
@@ -145,10 +110,14 @@
 
 -- | An 'IndexedTraversal' of the individual bytes in a lazy 'BL.ByteString'
 traversedLazy :: IndexedTraversal' Int64 BL.ByteString Word8
-traversedLazy pafb = go 0 where
-  go _ BLI.Empty        = pure BLI.Empty
-  go i (BLI.Chunk b bs) = BLI.Chunk <$> reindexed (fromIntegral :: Int -> Int64) (traversedStrictTree (fromIntegral i)) pafb b <*> go i' bs
-    where !i' = i + B.length b
+traversedLazy pafb = \lbs -> foldrChunks go (\_ -> pure BL.empty) lbs 0
+  where
+  go c fcs acc = BL.append . fromStrict
+             <$> reindexed (\x -> acc + fromIntegral x :: Int64) traversedStrictTree pafb c
+             <*> fcs acc'
+    where
+    acc' :: Int64
+    !acc' = acc + fromIntegral (B.length c)
 {-# INLINE traversedLazy #-}
 
 
@@ -159,16 +128,36 @@
 
 -- | An 'IndexedTraversal' of the individual bytes in a lazy 'BL.ByteString' pretending the bytes are chars.
 traversedLazy8 :: IndexedTraversal' Int64 BL.ByteString Char
-traversedLazy8 pafb = go 0 where
-  go _ BLI.Empty = pure BLI.Empty
-  go i (BLI.Chunk b bs) = BLI.Chunk <$> reindexed (fromIntegral :: Int -> Int64) (traversedStrictTree8 (fromIntegral i)) pafb b <*> go i' bs
-    where !i' = i + B.length b
+traversedLazy8 pafb = \lbs -> foldrChunks go (\_ -> pure BL.empty) lbs 0
+  where
+  go c fcs acc = BL.append . fromStrict
+             <$> reindexed (\x -> acc + fromIntegral x :: Int64) traversedStrictTree8 pafb c
+             <*> fcs acc'
+    where
+    acc' :: Int64
+    !acc' = acc + fromIntegral (B.length c)
 {-# INLINE traversedLazy8 #-}
 
 ------------------------------------------------------------------------------
 -- ByteString guts
 ------------------------------------------------------------------------------
 
+fromStrict :: B.ByteString -> BL.ByteString
+#if MIN_VERSION_bytestring(0,10,0)
+fromStrict = BL.fromStrict
+#else
+fromStrict = \x -> BL.fromChunks [x]
+#endif
+{-# INLINE fromStrict #-}
+
+foldrChunks :: (B.ByteString -> r -> r) -> r -> BL.ByteString -> r
+#if MIN_VERSION_bytestring(0,10,0)
+foldrChunks = BL.foldrChunks
+#else
+foldrChunks f z b = foldr f z (BL.toChunks b)
+#endif
+{-# INLINE foldrChunks #-}
+
 -- | Conversion between 'Word8' and 'Char'. Should compile to a no-op.
 w2c :: Word8 -> Char
 w2c = unsafeChr . fromIntegral
@@ -181,10 +170,11 @@
 c2w = fromIntegral . ord
 {-# INLINE c2w #-}
 
--- TODO: Should this create the list in chunks, like unpackBytes does in 0.10?
-
 -- | Unpack a strict 'B.Bytestring'
 unpackStrict :: B.ByteString -> [Word8]
+#if MIN_VERSION_bytestring(0,10,4)
+unpackStrict = B.unpack
+#else
 unpackStrict (BI.PS fp off len) =
       let p = unsafeForeignPtrToPtr fp
        in go (p `plusPtr` off) (p `plusPtr` (off+len))
@@ -195,12 +185,14 @@
                                         touchForeignPtr fp
                                         return x'
                              in x : go (p `plusPtr` 1) q
+#endif
 {-# INLINE unpackStrict #-}
 
--- TODO: Should this create the list in chunks, like unpackBytes does in 0.10?
-
 -- | Unpack a strict 'B.Bytestring', pretending the bytes are chars.
 unpackStrict8 :: B.ByteString -> String
+#if MIN_VERSION_bytestring(0,10,4)
+unpackStrict8 = B8.unpack
+#else
 unpackStrict8 (BI.PS fp off len) =
       let p = unsafeForeignPtrToPtr fp
        in go (p `plusPtr` off) (p `plusPtr` (off+len))
@@ -211,6 +203,7 @@
                                         touchForeignPtr fp
                                         return x'
                              in w2c x : go (p `plusPtr` 1) q
+#endif
 {-# INLINE unpackStrict8 #-}
 
 
diff --git a/src/Control/Lens/Internal/Coerce.hs b/src/Control/Lens/Internal/Coerce.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Lens/Internal/Coerce.hs
@@ -0,0 +1,48 @@
+{-# LANGUAGE CPP #-}
+
+#ifndef MIN_VERSION_profunctors
+#define MIN_VERSION_profunctors(x,y,z) 0
+#endif
+
+#if (MIN_VERSION_profunctors(4,4,0)) && __GLASGOW_HASKELL__ >= 708
+#define USE_COERCE
+{-# LANGUAGE Trustworthy #-}
+{-# LANGUAGE RankNTypes #-}
+{-# LANGUAGE ScopedTypeVariables #-}
+#else
+{-# LANGUAGE Unsafe #-}
+#endif
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2015 Edward Kmett and Eric Mertens
+-- License     :  BSD-style (see the file LICENSE)
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- This module provides a shim around 'coerce' that defaults to 'unsafeCoerce'
+-- on GHC < 7.8
+-----------------------------------------------------------------------------
+module Control.Lens.Internal.Coerce
+  ( coerce
+  , coerce'
+  ) where
+
+#ifdef USE_COERCE
+
+import Data.Coerce
+
+coerce' :: forall a b. Coercible a b => b -> a
+coerce' = coerce (id :: a -> a)
+{-# INLINE coerce' #-}
+
+#else
+
+import Unsafe.Coerce
+
+coerce, coerce' :: a -> b
+coerce  = unsafeCoerce
+coerce' = unsafeCoerce
+{-# INLINE coerce #-}
+{-# INLINE coerce' #-}
+#endif
diff --git a/src/Control/Lens/Internal/Context.hs b/src/Control/Lens/Internal/Context.hs
--- a/src/Control/Lens/Internal/Context.hs
+++ b/src/Control/Lens/Internal/Context.hs
@@ -15,7 +15,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Context
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Deque.hs b/src/Control/Lens/Internal/Deque.hs
--- a/src/Control/Lens/Internal/Deque.hs
+++ b/src/Control/Lens/Internal/Deque.hs
@@ -13,7 +13,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Deque
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Exception.hs b/src/Control/Lens/Internal/Exception.hs
--- a/src/Control/Lens/Internal/Exception.hs
+++ b/src/Control/Lens/Internal/Exception.hs
@@ -19,7 +19,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Exception
--- Copyright   :  (C) 2013-2014 Edward Kmett
+-- Copyright   :  (C) 2013-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -181,11 +181,7 @@
   {-# INLINE typeOf #-}
 
 handlingTyCon :: TyCon
-#if MIN_VERSION_base(4,4,0)
 handlingTyCon = mkTyCon3 "lens" "Control.Lens.Internal.Exception" "Handling"
-#else
-handlingTyCon = mkTyCon "Control.Lns.Internal.Exception.Handling"
-#endif
 {-# NOINLINE handlingTyCon #-}
 #endif
 
@@ -194,7 +190,7 @@
   showsPrec d _ = showParen (d > 10) $ showString "Handling ..."
   {-# INLINE showsPrec #-}
 
-instance (Reifies s (SomeException -> Maybe a), Typeable a, Typeable1 m, Typeable s) => Exception (Handling a s m) where
+instance (Reifies s (SomeException -> Maybe a), Typeable (Handling a s m)) => Exception (Handling a s m) where
   toException _ = SomeException HandlingException
   {-# INLINE toException #-}
   fromException = fmap Handling . reflect (Proxy :: Proxy s)
diff --git a/src/Control/Lens/Internal/FieldTH.hs b/src/Control/Lens/Internal/FieldTH.hs
--- a/src/Control/Lens/Internal/FieldTH.hs
+++ b/src/Control/Lens/Internal/FieldTH.hs
@@ -7,7 +7,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.FieldTH
--- Copyright   :  (C) 2014 Edward Kmett, (C) 2014 Eric Mertens
+-- Copyright   :  (C) 2014-2015 Edward Kmett, (C) 2014 Eric Mertens
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -274,7 +274,7 @@
           TopName n      -> fun n
           MethodName c n -> [makeFieldInstance defType c (fun n)]
 
-  clauses = makeFieldClauses opticType cons
+  clauses = makeFieldClauses rules opticType cons
 
 
 ------------------------------------------------------------------------
@@ -375,8 +375,8 @@
 ------------------------------------------------------------------------
 
 
-makeFieldClauses :: OpticType -> [(Name, Int, [Int])] -> [ClauseQ]
-makeFieldClauses opticType cons =
+makeFieldClauses :: LensRules -> OpticType -> [(Name, Int, [Int])] -> [ClauseQ]
+makeFieldClauses rules opticType cons =
   case opticType of
 
     IsoType    -> [ makeIsoClause conName | (conName, _, _) <- cons ]
@@ -384,11 +384,14 @@
     GetterType -> [ makeGetterClause conName fieldCount fields
                     | (conName, fieldCount, fields) <- cons ]
 
-    LensType   -> let irref = length cons == 1 in
-                  [ makeFieldOpticClause conName fieldCount fields irref
+    LensType   -> [ makeFieldOpticClause conName fieldCount fields irref
                     | (conName, fieldCount, fields) <- cons ]
+      where
+      irref = _lazyPatterns rules
+           && length cons == 1
 
 
+
 -- | Construct an optic clause that returns an unmodified value
 -- given a constructor name and the number of fields on that
 -- constructor.
@@ -545,6 +548,7 @@
   , _generateClasses :: Bool
   , _allowIsos       :: Bool
   , _allowUpdates    :: Bool -- ^ Allow Lens/Traversal (otherwise Getter/Fold)
+  , _lazyPatterns    :: Bool
   , _fieldToDef      :: Name -> [Name] -> Name -> [DefName]
        -- ^ Type Name -> Field Names -> Target Field Name -> Definition Names
   , _classyLenses    :: Name -> Maybe (Name,Name)
diff --git a/src/Control/Lens/Internal/Fold.hs b/src/Control/Lens/Internal/Fold.hs
--- a/src/Control/Lens/Internal/Fold.hs
+++ b/src/Control/Lens/Internal/Fold.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Fold
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Getter.hs b/src/Control/Lens/Internal/Getter.hs
--- a/src/Control/Lens/Internal/Getter.hs
+++ b/src/Control/Lens/Internal/Getter.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Getter
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Internal/Indexed.hs b/src/Control/Lens/Internal/Indexed.hs
--- a/src/Control/Lens/Internal/Indexed.hs
+++ b/src/Control/Lens/Internal/Indexed.hs
@@ -3,6 +3,7 @@
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE FlexibleContexts #-}
 {-# LANGUAGE FlexibleInstances #-}
+{-# LANGUAGE ScopedTypeVariables #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 #ifdef TRUSTWORTHY
 {-# LANGUAGE Trustworthy #-}
@@ -10,7 +11,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Indexed
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -50,7 +51,7 @@
 import Prelude hiding ((.),id)
 #ifndef SAFE
 import Data.Profunctor.Unsafe
-import Unsafe.Coerce
+import Control.Lens.Internal.Coerce
 #endif
 
 ------------------------------------------------------------------------------
@@ -147,9 +148,9 @@
   rmap bc iab = Indexed $ \i -> bc . runIndexed iab i
   {-# INLINE rmap #-}
 #ifndef SAFE
-  ( .# ) ibc _ = unsafeCoerce ibc
+  ( .# ) ibc _ = coerce ibc
   {-# INLINE ( .# ) #-}
-  ( #. ) _ = unsafeCoerce
+  ( #. ) _ = coerce'
   {-# INLINE ( #. ) #-}
 #endif
 
diff --git a/src/Control/Lens/Internal/Instances.hs b/src/Control/Lens/Internal/Instances.hs
--- a/src/Control/Lens/Internal/Instances.hs
+++ b/src/Control/Lens/Internal/Instances.hs
@@ -11,7 +11,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Instances
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Iso.hs b/src/Control/Lens/Internal/Iso.hs
--- a/src/Control/Lens/Internal/Iso.hs
+++ b/src/Control/Lens/Internal/Iso.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Iso
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -20,7 +20,7 @@
 import Data.Profunctor
 #ifndef SAFE
 import Data.Profunctor.Unsafe
-import Unsafe.Coerce
+import Control.Lens.Internal.Coerce
 #endif
 import Data.ByteString       as StrictB
 import Data.ByteString.Lazy  as LazyB
@@ -52,9 +52,9 @@
   rmap f (Exchange sa bt) = Exchange sa (f . bt)
   {-# INLINE rmap #-}
 #ifndef SAFE
-  ( #. ) _ = unsafeCoerce
+  ( #. ) _ = coerce'
   {-# INLINE ( #. ) #-}
-  ( .# ) p _ = unsafeCoerce p
+  ( .# ) p _ = coerce p
   {-# INLINE ( .# ) #-}
 #endif
 
diff --git a/src/Control/Lens/Internal/Level.hs b/src/Control/Lens/Internal/Level.hs
--- a/src/Control/Lens/Internal/Level.hs
+++ b/src/Control/Lens/Internal/Level.hs
@@ -8,7 +8,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Level
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/List.hs b/src/Control/Lens/Internal/List.hs
new file mode 100644
--- /dev/null
+++ b/src/Control/Lens/Internal/List.hs
@@ -0,0 +1,41 @@
+-------------------------------------------------------------------------------
+-- |
+-- Module      :  Control.Lens.Internal.List
+-- Copyright   :  (C) 2014-2015 Edward Kmett and Eric Mertens
+-- License     :  BSD-style (see the file LICENSE)
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  provisional
+-- Portability :  non-portable
+--
+-- This module provides utility functions on lists used by the library
+-- implementation.
+-------------------------------------------------------------------------------
+module Control.Lens.Internal.List
+  ( ordinalNub
+  ) where
+
+import Data.IntSet (IntSet)
+import qualified Data.IntSet as IntSet
+
+{-# ANN module "HLint: ignore Redundant bracket" #-}
+
+-- | Return the the subset of given ordinals within a given bound
+-- and in order of the first occurrence seen.
+--
+-- Bound: @0 <= x < l@
+--
+-- >>> ordinalNub 3 [-1,2,1,4,2,3]
+-- [2,1]
+ordinalNub ::
+  Int   {- ^ strict upper bound -} ->
+  [Int] {- ^ ordinals           -} ->
+  [Int] {- ^ unique, in-bound ordinals, in order seen -}
+ordinalNub l xs = foldr (ordinalNubHelper l) (const []) xs IntSet.empty
+
+ordinalNubHelper :: Int -> Int -> (IntSet -> [Int]) -> (IntSet -> [Int])
+ordinalNubHelper l x next seen
+  | outOfBounds || notUnique = next seen
+  | otherwise                = x : next (IntSet.insert x seen)
+  where
+  outOfBounds = x < 0 || l <= x
+  notUnique   = x `IntSet.member` seen
diff --git a/src/Control/Lens/Internal/Magma.hs b/src/Control/Lens/Internal/Magma.hs
--- a/src/Control/Lens/Internal/Magma.hs
+++ b/src/Control/Lens/Internal/Magma.hs
@@ -16,7 +16,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Magma
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -225,7 +225,7 @@
 #endif
 
 -- | Generate a 'Magma' with leaves only while the predicate holds from left to right.
-runTakingWhile :: Corepresentable p => TakingWhile p f a b t -> Magma () t b (Corep p a)
+runTakingWhile :: TakingWhile p f a b t -> Magma () t b (Corep p a)
 runTakingWhile (TakingWhile _ _ k) = k True
 
 instance Functor (TakingWhile p f a b) where
@@ -253,6 +253,7 @@
     go (Magma _ wa) = corep pafb wa
   {-# INLINE bazaar #-}
 
+-- This constraint is unused intentionally, it protects TakingWhile
 instance Contravariant f => Contravariant (TakingWhile p f a b) where
   contramap _ = (<$) (error "contramap: TakingWhile")
   {-# INLINE contramap #-}
diff --git a/src/Control/Lens/Internal/Prism.hs b/src/Control/Lens/Internal/Prism.hs
--- a/src/Control/Lens/Internal/Prism.hs
+++ b/src/Control/Lens/Internal/Prism.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Prism
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -20,7 +20,7 @@
 import Data.Profunctor
 #ifndef SAFE
 import Data.Profunctor.Unsafe
-import Unsafe.Coerce
+import Control.Lens.Internal.Coerce
 #endif
 
 ------------------------------------------------------------------------------
@@ -47,9 +47,9 @@
   {-# INLINE rmap #-}
 
 #ifndef SAFE
-  ( #. ) _ = unsafeCoerce
+  ( #. ) _ = coerce'
   {-# INLINE ( #. ) #-}
-  ( .# ) p _ = unsafeCoerce p
+  ( .# ) p _ = coerce p
   {-# INLINE ( .# ) #-}
 #endif
 
diff --git a/src/Control/Lens/Internal/PrismTH.hs b/src/Control/Lens/Internal/PrismTH.hs
--- a/src/Control/Lens/Internal/PrismTH.hs
+++ b/src/Control/Lens/Internal/PrismTH.hs
@@ -6,7 +6,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.PrismTH
--- Copyright   :  (C) 2014 Edward Kmett, (C) 2014 Eric Mertens
+-- Copyright   :  (C) 2014-2015 Edward Kmett and Eric Mertens
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Internal/Reflection.hs b/src/Control/Lens/Internal/Reflection.hs
--- a/src/Control/Lens/Internal/Reflection.hs
+++ b/src/Control/Lens/Internal/Reflection.hs
@@ -13,7 +13,7 @@
 ----------------------------------------------------------------------------
 -- |
 -- Module     : Control.Lens.Internal.Reflection
--- Copyright  : 2009-2014 Edward Kmett,
+-- Copyright  : 2009-2015 Edward Kmett,
 --              2012 Elliott Hird,
 --              2004 Oleg Kiselyov and Chung-chieh Shan
 -- License    : BSD3
@@ -180,7 +180,7 @@
 
 -- This had to be moved to the top level, due to an apparent bug in
 -- the ghc inliner introduced in ghc 7.0.x
-reflectBefore :: Reifies s a => (Proxy s -> b) -> proxy s -> b
+reflectBefore :: (Proxy s -> b) -> proxy s -> b
 reflectBefore f = const $! f Proxy
 {-# NOINLINE reflectBefore #-}
 
diff --git a/src/Control/Lens/Internal/Review.hs b/src/Control/Lens/Internal/Review.hs
--- a/src/Control/Lens/Internal/Review.hs
+++ b/src/Control/Lens/Internal/Review.hs
@@ -6,7 +6,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Review
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Internal/Setter.hs b/src/Control/Lens/Internal/Setter.hs
--- a/src/Control/Lens/Internal/Setter.hs
+++ b/src/Control/Lens/Internal/Setter.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Setter
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Internal/TH.hs b/src/Control/Lens/Internal/TH.hs
--- a/src/Control/Lens/Internal/TH.hs
+++ b/src/Control/Lens/Internal/TH.hs
@@ -21,7 +21,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.TH
--- Copyright   :  (C) 2013-2014 Edward Kmett, 2013 Eric Mertens
+-- Copyright   :  (C) 2013-2015 Edward Kmett and Eric Mertens
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -80,11 +80,11 @@
 bndrName (PlainTV  n  ) = n
 bndrName (KindedTV n _) = n
 
-fromSet :: Ord k => (k -> v) -> Set.Set k -> Map.Map k v
+fromSet :: (k -> v) -> Set.Set k -> Map.Map k v
 #if MIN_VERSION_containers(0,5,0)
 fromSet = Map.fromSet
 #else
-fromSet f x = Map.fromList [ (k,f k) | k <- Set.toList x ]
+fromSet f x = Map.fromDistinctAscList [ (k,f k) | k <- Set.toAscList x ]
 #endif
 
 ------------------------------------------------------------------------
diff --git a/src/Control/Lens/Internal/Zoom.hs b/src/Control/Lens/Internal/Zoom.hs
--- a/src/Control/Lens/Internal/Zoom.hs
+++ b/src/Control/Lens/Internal/Zoom.hs
@@ -9,7 +9,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Internal.Zoom
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
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,7 +12,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Iso
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Lens.hs b/src/Control/Lens/Lens.hs
--- a/src/Control/Lens/Lens.hs
+++ b/src/Control/Lens/Lens.hs
@@ -15,7 +15,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -120,6 +120,9 @@
   , Context(..)
   , Context'
   , locus
+
+  -- * Lens fusion
+  , fusing
   ) where
 
 import Control.Applicative
@@ -130,12 +133,16 @@
 import Control.Lens.Internal.Indexed
 import Control.Lens.Type
 import Control.Monad.State as State
+import Data.Functor.Yoneda
 import Data.Monoid
 import Data.Profunctor
 import Data.Profunctor.Rep
 import Data.Profunctor.Unsafe
 import Data.Void
 import Prelude
+#if __GLASGOW_HASKELL__ >= 710
+import Data.Function ((&))
+#endif
 
 #ifdef HLINT
 {-# ANN module "HLint: ignore Use ***" #-}
@@ -159,7 +166,7 @@
 infix  4 %%@=, <%@=, <<%@=, %%=, <+=, <*=, <-=, <//=, <^=, <^^=, <**=, <&&=, <||=, <<>=, <%=, <<%=, <<.=, <#=, #=, #%=, <#%=, #%%=
        , <<+=, <<-=, <<*=, <<//=, <<^=, <<^^=, <<**=, <<||=, <<&&=, <<<>=
 infixr 2 <<~
-infixl 1 &, <&>, ??, &~
+infixl 1 <&>, ??, &~
 
 -------------------------------------------------------------------------------
 -- Lenses
@@ -312,6 +319,8 @@
 -- General Purpose Combinators
 -------------------------------------------------------------------------------
 
+
+#if __GLASGOW_HASKELL__ < 710
 -- | Passes the result of the left side to the function on the right side (forward pipe operator).
 --
 -- This is the flipped version of ('$'), which is more common in languages like F# as (@|>@) where it is needed
@@ -336,6 +345,8 @@
 (&) :: a -> (a -> b) -> b
 a & f = f a
 {-# INLINE (&) #-}
+infixl 1 &
+#endif
 
 -- | Infix flipped 'fmap'.
 --
@@ -1195,7 +1206,9 @@
 -- adjust all of the targets of an 'Control.Lens.Traversal.IndexedTraversal' and return a monoidal summary
 -- along with the answer.
 --
--- @l '<%~' f ≡ l '<%@~' 'const' f@
+-- @
+-- l '<%~' f ≡ l '<%@~' 'const' f
+-- @
 --
 -- When you do not need access to the index then ('<%~') is more liberal in what it can accept.
 --
@@ -1226,7 +1239,9 @@
 -- adjust all of the targets of an 'Control.Lens.Traversal.IndexedTraversal' and return a monoidal summary
 -- of the supplementary results and the answer.
 --
--- @('%%@~') ≡ 'Control.Lens.Indexed.withIndex'@
+-- @
+-- ('%%@~') ≡ 'Control.Lens.Indexed.withIndex'
+-- @
 --
 -- @
 -- ('%%@~') :: 'Functor' f => 'IndexedLens' i s t a b      -> (i -> a -> f b) -> s -> f t
@@ -1248,7 +1263,9 @@
 -- adjust all of the targets of an 'Control.Lens.Traversal.IndexedTraversal' within the current state, and
 -- return a monoidal summary of the supplementary results.
 --
--- @l '%%@=' f ≡ 'state' (l '%%@~' f)@
+-- @
+-- l '%%@=' f ≡ 'state' (l '%%@~' f)
+-- @
 --
 -- @
 -- ('%%@=') :: 'MonadState' s m                 => 'IndexedLens' i s s a b      -> (i -> a -> (r, b)) -> s -> m r
@@ -1416,3 +1433,26 @@
 united :: Lens' a ()
 united f v = f () <&> \ () -> v
 {-# INLINE united #-}
+
+-- | Fuse a composition of lenses using 'Yoneda' to provide 'fmap' fusion.
+--
+-- In general, given a pair of lenses 'foo' and 'bar'
+--
+-- @
+-- fusing (foo.bar) = foo.bar
+-- @
+--
+-- however, @foo@ and @bar@ are either going to 'fmap' internally or they are trivial.
+--
+-- 'fusing' exploits the 'Yoneda' lemma to merge these separate uses into a single 'fmap'.
+--
+-- This is particularly effective when the choice of functor 'f' is unknown at compile
+-- time or when the 'Lens' @foo.bar@ in the above description is recursive or complex
+-- enough to prevent inlining.
+--
+-- @
+-- 'fusing' :: 'Lens' s t a b -> 'Lens' s t a b
+-- @
+fusing :: Functor f => LensLike (Yoneda f) s t a b -> LensLike f s t a b
+fusing t = \f -> lowerYoneda . t (liftYoneda . f)
+{-# INLINE fusing #-}
diff --git a/src/Control/Lens/Level.hs b/src/Control/Lens/Level.hs
--- a/src/Control/Lens/Level.hs
+++ b/src/Control/Lens/Level.hs
@@ -7,7 +7,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Level
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -36,7 +36,7 @@
 -- >>> import Data.Char
 
 levelIns :: Bazaar (->) a b t -> [Level () a]
-levelIns = go 0 . (getConst #. bazaar (Const #. deepening ())) where
+levelIns = go 0 . (getConst #. bazaar (rmapConst (deepening ()))) where
   go k z = k `seq` runDeepening z k $ \ xs b ->
     xs : if b then (go $! k + 1) z else []
 {-# INLINE levelIns #-}
@@ -83,8 +83,14 @@
   bz = l sell s
 {-# INLINE levels #-}
 
+-- This is only a temporary work around added to deal with a bug in an unreleased version
+-- of GHC 7.10. We should remove it as soon as we're able.
+rmapConst :: Profunctor p => p a b -> p a (Const b x)
+rmapConst p = Const #. p
+{-# INLINE rmapConst #-}
+
 ilevelIns :: Bazaar (Indexed i) a b t -> [Level i a]
-ilevelIns = go 0 . (getConst #. bazaar (Indexed $ \ i -> Const #. deepening i)) where
+ilevelIns = go 0 . (getConst #. bazaar (Indexed $ \ i -> rmapConst (deepening i))) where
   go k z = k `seq` runDeepening z k $ \ xs b ->
     xs : if b then (go $! k + 1) z else []
 {-# INLINE ilevelIns #-}
diff --git a/src/Control/Lens/Loupe.hs b/src/Control/Lens/Loupe.hs
deleted file mode 100644
--- a/src/Control/Lens/Loupe.hs
+++ /dev/null
@@ -1,43 +0,0 @@
--------------------------------------------------------------------------------
--- |
--- Module      :  Control.Lens.Loupe
--- Copyright   :  (C) 2012-14 Edward Kmett
--- License     :  BSD-style (see the file LICENSE)
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  Rank2Types
---
--- This module exports a minimalist API for working with lenses in highly
--- monomorphic settings.
--------------------------------------------------------------------------------
-module Control.Lens.Loupe
-  (
-    ALens, ALens'
-  , cloneLens
-  , storing
-  , (^#)
-  , ( #~ ), ( #%~ ), ( #%%~ ), (<#~), (<#%~)
-  , ( #= ), ( #%= ), ( #%%= ), (<#=), (<#%=)
-  -- * Deprecated Aliases
-  , Loupe, SimpleLoupe
-  ) where
-
-import Control.Lens.Internal.Context
-import Control.Lens.Lens
-import Control.Lens.Type
-
--- | This is an older alias for a type-restricted form of lens that is able to be passed around
--- in containers monomorphically.
---
--- Deprecated. This has since been renamed to 'ALens' for consistency.
-type Loupe s t a b = LensLike (Pretext (->) a b) s t a b
-{-# DEPRECATED Loupe "use ALens" #-}
-
--- | @
--- type 'SimpleLoupe' = 'Simple' 'Loupe'
--- @
---
--- Deprecated for two reasons. 'Loupe' is now 'ALens', and we no longer use the verbose @SimpleFoo@ naming
--- convention, this has since been renamed to 'ALens'' for consistency.
-type SimpleLoupe s a = Loupe s s a a
-{-# DEPRECATED SimpleLoupe "use ALens'" #-}
diff --git a/src/Control/Lens/Operators.hs b/src/Control/Lens/Operators.hs
--- a/src/Control/Lens/Operators.hs
+++ b/src/Control/Lens/Operators.hs
@@ -1,7 +1,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Operators
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Control/Lens/Plated.hs b/src/Control/Lens/Plated.hs
--- a/src/Control/Lens/Plated.hs
+++ b/src/Control/Lens/Plated.hs
@@ -3,8 +3,16 @@
 {-# LANGUAGE DefaultSignatures #-}
 {-# LANGUAGE FlexibleInstances #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE MultiParamTypeClasses #-}
 
+#if __GLASGOW_HASKELL__ < 710
+{-# LANGUAGE OverlappingInstances #-}
+#define OVERLAPPING_PRAGMA
+#else
+#define OVERLAPPING_PRAGMA {-# OVERLAPPING #-}
+#endif
+
 #ifdef TRUSTWORTHY
 {-# LANGUAGE Trustworthy #-} -- template-haskell
 #endif
@@ -19,7 +27,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Plated
--- Copyright   :  (C) 2012-13 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -80,6 +88,10 @@
 
   -- * Parts
   , parts
+
+  -- * Generics
+  , gplate
+  , GPlated
   )
   where
 
@@ -104,6 +116,7 @@
 import Data.Data.Lens
 import Data.Monoid
 import Data.Tree
+import GHC.Generics
 
 #ifdef HLINT
 {-# ANN module "HLint: ignore Reduce duplication" #-}
@@ -673,3 +686,44 @@
 parts :: Plated a => Lens' a [a]
 parts = partsOf plate
 {-# INLINE parts #-}
+
+-------------------------------------------------------------------------------
+-- Generics
+-------------------------------------------------------------------------------
+
+-- | Implement 'plate' operation for a type using its 'Generic' instance.
+gplate :: (Generic a, GPlated a (Rep a)) => Traversal' a a
+gplate f x = GHC.Generics.to <$> gplate' f (GHC.Generics.from x)
+{-# INLINE gplate #-}
+
+class GPlated a g where
+  gplate' :: Traversal' (g p) a
+
+instance GPlated a f => GPlated a (M1 i c f) where
+  gplate' f (M1 x) = M1 <$> gplate' f x
+  {-# INLINE gplate' #-}
+
+instance (GPlated a f, GPlated a g) => GPlated a (f :+: g) where
+  gplate' f (L1 x) = L1 <$> gplate' f x
+  gplate' f (R1 x) = R1 <$> gplate' f x
+  {-# INLINE gplate' #-}
+
+instance (GPlated a f, GPlated a g) => GPlated a (f :*: g) where
+  gplate' f (x :*: y) = (:*:) <$> gplate' f x <*> gplate' f y
+  {-# INLINE gplate' #-}
+
+instance OVERLAPPING_PRAGMA GPlated a (K1 i a) where
+  gplate' f (K1 x) = K1 <$> f x
+  {-# INLINE gplate' #-}
+
+instance GPlated a (K1 i b) where
+  gplate' _ = pure
+  {-# INLINE gplate' #-}
+
+instance GPlated a U1 where
+  gplate' _ = pure
+  {-# INLINE gplate' #-}
+
+instance GPlated a V1 where
+  gplate' _ v = v `seq` error "GPlated/V1"
+  {-# INLINE gplate' #-}
diff --git a/src/Control/Lens/Prism.hs b/src/Control/Lens/Prism.hs
--- a/src/Control/Lens/Prism.hs
+++ b/src/Control/Lens/Prism.hs
@@ -4,10 +4,15 @@
 #ifdef TRUSTWORTHY
 {-# LANGUAGE Trustworthy #-}
 #endif
+
+#ifndef MIN_VERSION_base
+#define MIN_VERSION_base(x,y,z) 1
+#endif
+
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Prism
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -55,10 +60,12 @@
 import Data.Profunctor.Rep
 import Data.Traversable
 import Data.Void
-#ifndef SAFE
-import Unsafe.Coerce
-#else
+#if MIN_VERSION_base(4,7,0)
+import Data.Coerce
+#elif defined(SAFE)
 import Data.Profunctor.Unsafe
+#else
+import Unsafe.Coerce
 #endif
 import Prelude
 
@@ -89,7 +96,10 @@
 
 -- | Convert 'APrism' to the pair of functions that characterize it.
 withPrism :: APrism s t a b -> ((b -> t) -> (s -> Either t a) -> r) -> r
-#ifdef SAFE
+#if MIN_VERSION_base(4,7,0)
+withPrism k f = case coerce (k (Market Identity Right)) of
+  Market bt seta -> f bt seta
+#elif defined(SAFE)
 withPrism k f = case k (Market Identity Right) of
   Market bt seta -> f (runIdentity #. bt) (either (Left . runIdentity) Right . seta)
 #else
@@ -160,6 +170,12 @@
 {-# INLINE aside #-}
 
 -- | 'lift' a 'Prism' through a 'Traversable' functor, giving a Prism that matches only if all the elements of the container match the 'Prism'.
+--
+-- >>> [Left 1, Right "foo", Left 4, Right "woot"]^..below _Right
+-- []
+--
+-- >>> [Right "hail hydra!", Right "foo", Right "blah", Right "woot"]^..below _Right
+-- [["hail hydra!","foo","blah","woot"]]
 below :: Traversable f => APrism' s a -> Prism' (f s) (f a)
 below k =
   withPrism k     $ \bt seta ->
diff --git a/src/Control/Lens/Reified.hs b/src/Control/Lens/Reified.hs
--- a/src/Control/Lens/Reified.hs
+++ b/src/Control/Lens/Reified.hs
@@ -5,7 +5,7 @@
 ------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Reified
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Lens/Review.hs b/src/Control/Lens/Review.hs
--- a/src/Control/Lens/Review.hs
+++ b/src/Control/Lens/Review.hs
@@ -6,7 +6,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Review
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -116,7 +116,7 @@
 -- 're' :: 'Prism' s t a b -> 'Getter' b t
 -- 're' :: 'Iso' s t a b   -> 'Getter' b t
 -- @
-re :: AReview t b -> Getter b t
+re :: Contravariant f => AReview t b -> LensLike' f b t
 re p = to (runIdentity #. unTagged #. p .# Tagged .# Identity)
 {-# INLINE re #-}
 
@@ -141,8 +141,8 @@
 -- 'review' :: 'Prism'' s a -> a -> s
 -- @
 --
--- However, when working with a 'Monad' transformer stack, it is sometimes useful to be able to 'review' the current environment, in which case one of
--- these more slightly more liberal type signatures may be beneficial to think of it as having:
+-- However, when working with a 'Monad' transformer stack, it is sometimes useful to be able to 'review' the current environment, in which case
+-- it may be beneficial to think of it as having one of these slightly more liberal type signatures:
 --
 -- @
 -- 'review' :: 'MonadReader' a m => 'Iso'' s a   -> m s
@@ -201,8 +201,8 @@
 -- 'reviews' :: 'Prism'' s a -> (s -> r) -> a -> r
 -- @
 --
--- However, when working with a 'Monad' transformer stack, it is sometimes useful to be able to 'review' the current environment, in which case one of
--- these more slightly more liberal type signatures may be beneficial to think of it as having:
+-- However, when working with a 'Monad' transformer stack, it is sometimes useful to be able to 'review' the current environment, in which case
+-- it may be beneficial to think of it as having one of these slightly more liberal type signatures:
 --
 -- @
 -- 'reviews' :: 'MonadReader' a m => 'Iso'' s a   -> (s -> r) -> m r
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
@@ -9,7 +9,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Setter
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -63,9 +63,9 @@
   -- * Simplified State Setting
   , set'
   -- * Indexed Setters
-  , imapOf, iover
+  , imapOf, iover, iset
   , isets
-  , (%@~), (%@=)
+  , (%@~), (.@~), (%@=), (.@=)
   -- * Arrow operators
   , assignA
   -- * Exported for legible error messages
@@ -110,8 +110,8 @@
 -- >>> let setter :: Expr -> Expr -> Expr; setter = fun "setter"
 -- >>> :set -XNoOverloadedStrings
 
-infixr 4 %@~, .~, +~, *~, -~, //~, ^~, ^^~, **~, &&~, <>~, ||~, %~, <.~, ?~, <?~
-infix  4 %@=, .=, +=, *=, -=, //=, ^=, ^^=, **=, &&=, <>=, ||=, %=, <.=, ?=, <?=
+infixr 4 %@~, .@~, .~, +~, *~, -~, //~, ^~, ^^~, **~, &&~, <>~, ||~, %~, <.~, ?~, <?~
+infix  4 %@=, .@=, .=, +=, *=, -=, //=, ^=, ^^=, **=, &&=, <>=, ||=, %=, <.=, ?=, <?=
 infixr 2 <~
 
 ------------------------------------------------------------------------------
@@ -1126,6 +1126,23 @@
 iover l = over l .# Indexed
 {-# INLINE iover #-}
 
+-- | Set with index. Equivalent to 'iover' with the current value ignored.
+--
+-- When you do not need access to the index, then 'set' is more liberal in what it can accept.
+--
+-- @
+-- 'set' l ≡ 'iset' l '.' 'const'
+-- @
+--
+-- @
+-- 'iset' :: 'IndexedSetter' i s t a b    -> (i -> b) -> s -> t
+-- 'iset' :: 'IndexedLens' i s t a b      -> (i -> b) -> s -> t
+-- 'iset' :: 'IndexedTraversal' i s t a b -> (i -> b) -> s -> t
+-- @
+iset :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+iset l = iover l . (const .)
+{-# INLINE iset #-}
+
 -- | Build an 'IndexedSetter' from an 'Control.Lens.Indexed.imap'-like function.
 --
 -- Your supplied function @f@ is required to satisfy:
@@ -1152,10 +1169,10 @@
 -- with access to the index.
 --
 -- @
--- ('%@~') ≡ 'imapOf'
+-- ('%@~') ≡ 'iover'
 -- @
 --
--- When you do not need access to the index then ('%@~') is more liberal in what it can accept.
+-- When you do not need access to the index then ('%~') is more liberal in what it can accept.
 --
 -- @
 -- l '%~' f ≡ l '%@~' 'const' f
@@ -1170,6 +1187,28 @@
 l %@~ f = l %~ Indexed f
 {-# INLINE (%@~) #-}
 
+-- | Replace every target of an 'IndexedSetter', 'IndexedLens' or 'IndexedTraversal'
+-- with access to the index.
+--
+-- @
+-- ('.@~') ≡ 'iset'
+-- @
+--
+-- When you do not need access to the index then ('.~') is more liberal in what it can accept.
+--
+-- @
+-- l '.~' b ≡ l '.@~' 'const' b
+-- @
+--
+-- @
+-- ('.@~') :: 'IndexedSetter' i s t a b    -> (i -> b) -> s -> t
+-- ('.@~') :: 'IndexedLens' i s t a b      -> (i -> b) -> s -> t
+-- ('.@~') :: 'IndexedTraversal' i s t a b -> (i -> b) -> s -> t
+-- @
+(.@~) :: AnIndexedSetter i s t a b -> (i -> b) -> s -> t
+l .@~ f = l %~ Indexed (const . f)
+{-# INLINE (.@~) #-}
+
 -- | Adjust every target in the current state of an 'IndexedSetter', 'IndexedLens' or 'IndexedTraversal'
 -- with access to the index.
 --
@@ -1187,6 +1226,24 @@
 (%@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> a -> b) -> m ()
 l %@= f = State.modify (l %@~ f)
 {-# INLINE (%@=) #-}
+
+-- | Replace every target in the current state of an 'IndexedSetter', 'IndexedLens' or 'IndexedTraversal'
+-- with access to the index.
+--
+-- When you do not need access to the index then ('.=') is more liberal in what it can accept.
+--
+-- @
+-- l '.=' b ≡ l '.@=' 'const' b
+-- @
+--
+-- @
+-- ('.@=') :: 'MonadState' s m => 'IndexedSetter' i s s a b    -> (i -> b) -> m ()
+-- ('.@=') :: 'MonadState' s m => 'IndexedLens' i s s a b      -> (i -> b) -> m ()
+-- ('.@=') :: 'MonadState' s m => 'IndexedTraversal' i s t a b -> (i -> b) -> m ()
+-- @
+(.@=) :: MonadState s m => AnIndexedSetter i s s a b -> (i -> b) -> m ()
+l .@= f = State.modify (l .@~ f)
+{-# INLINE (.@=) #-}
 
 ------------------------------------------------------------------------------
 -- Arrows
diff --git a/src/Control/Lens/TH.hs b/src/Control/Lens/TH.hs
--- a/src/Control/Lens/TH.hs
+++ b/src/Control/Lens/TH.hs
@@ -10,7 +10,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.TH
--- Copyright   :  (C) 2012-14 Edward Kmett, Michael Sloan
+-- Copyright   :  (C) 2012-15 Edward Kmett, 2012-13 Michael Sloan
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -26,7 +26,6 @@
   , makeClassyPrisms
   , makeWrapped
   , makeFields
-  , makeFieldsWith
   -- * Constructing Lenses Given a Declaration Quote
   , declareLenses, declareLensesFor
   , declareClassy, declareClassyFor
@@ -52,6 +51,7 @@
   , createClass
   , generateSignatures
   , generateUpdateableOptics
+  , generateLazyPatterns
   ) where
 
 import Control.Applicative
@@ -109,6 +109,23 @@
 generateUpdateableOptics f r =
   fmap (\x -> r { _allowUpdates = x}) (f (_allowUpdates r))
 
+-- | Generate optics using lazy pattern matches. This can
+-- allow fields of an undefined value to be initialized with lenses,
+-- and is the default behavior.
+--
+-- The downside of this flag is that it can lead to space-leaks and
+-- code-size/compile-time increases when generated for large records.
+--
+-- When using lazy optics the strict optic can be recovered by composing
+-- with '$!'
+--
+-- @
+-- strictOptic = ($!) . lazyOptic
+-- @
+generateLazyPatterns :: Lens' LensRules Bool
+generateLazyPatterns f r =
+  fmap (\x -> r { _lazyPatterns = x}) (f (_lazyPatterns r))
+
 -- | Create the class if the constructor is 'Control.Lens.Type.Simple' and the
 -- 'lensClass' rule matches.
 createClass :: Lens' LensRules Bool
@@ -147,6 +164,7 @@
   , _generateClasses = False
   , _allowIsos       = True
   , _allowUpdates    = True
+  , _lazyPatterns    = False
   , _classyLenses    = const Nothing
   , _fieldToDef      = \_ _ n ->
        case nameBase n of
@@ -173,6 +191,7 @@
   , _generateClasses = True
   , _allowIsos       = False -- generating Isos would hinder "subtyping"
   , _allowUpdates    = True
+  , _lazyPatterns    = False
   , _classyLenses    = \n ->
         case nameBase n of
           x:xs -> Just (mkName ("Has" ++ x:xs), mkName (toLower x:xs))
@@ -667,11 +686,6 @@
 makeFields :: Name -> DecsQ
 makeFields = makeFieldOptics camelCaseFields
 
--- | Deprecated alias for 'makeLensesWith'
-makeFieldsWith :: LensRules -> Name -> DecsQ
-makeFieldsWith = makeLensesWith
-{-# DEPRECATED makeFieldsWith "Use `makeLensesWith`, functionality merged" #-}
-
 defaultFieldRules :: LensRules
 defaultFieldRules = LensRules
   { _simpleLenses    = True
@@ -679,6 +693,7 @@
   , _generateClasses = True  -- classes will still be skipped if they already exist
   , _allowIsos       = False -- generating Isos would hinder field class reuse
   , _allowUpdates    = True
+  , _lazyPatterns    = False
   , _classyLenses    = const Nothing
   , _fieldToDef      = camelCaseNamer
   }
diff --git a/src/Control/Lens/Traversal.hs b/src/Control/Lens/Traversal.hs
--- a/src/Control/Lens/Traversal.hs
+++ b/src/Control/Lens/Traversal.hs
@@ -17,7 +17,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Traversal
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -121,6 +121,9 @@
   , Bazaar1(..), Bazaar1'
   , loci
   , iloci
+
+  -- * Fusion
+  , confusing
   ) where
 
 import Control.Applicative as Applicative
@@ -138,6 +141,8 @@
 import Control.Monad.Trans.State.Lazy
 import Data.Bitraversable
 import Data.Functor.Compose
+import Data.Functor.Kan.Rift
+import Data.Functor.Yoneda
 import Data.Int
 import Data.IntMap as IntMap
 import Data.Map as Map
@@ -1216,3 +1221,41 @@
           [] -> r go s
           xs -> unsafeOuts b <$> traverse (corep pafb) xs
           where b = l sell s
+
+-- | "Fuse" a 'Traversal' by reassociating all of the '<*>' operations to the
+-- left and fusing all of the 'fmap' calls into one. This is particularly
+-- useful when constructing a 'Traversal' using operations from GHC.Generics.
+--
+-- Given a pair of 'Traversal's 'foo' and 'bar',
+--
+-- @
+-- 'confusing' (foo.bar) = foo.bar
+-- @
+--
+-- However, @foo@ and @bar@ are each going to use the 'Applicative' they are given.
+--
+-- 'confusing' exploits the 'Yoneda' lemma to merge their separate uses of 'fmap' into a single 'fmap'.
+-- and it further exploits an interesting property of the right Kan lift (or 'Rift') to left associate
+-- all of the uses of '(<*>)' to make it possible to fuse together more fmaps.
+--
+-- This is particularly effective when the choice of functor 'f' is unknown at compile
+-- time or when the 'Traversal' @foo.bar@ in the above description is recursive or complex
+-- enough to prevent inlining.
+--
+-- 'Control.Lens.Lens.fusing' is a version of this combinator suitable for fusing lenses.
+--
+-- @
+-- 'confusing' :: 'Traversal' s t a b -> 'Traversal' s t a b
+-- @
+confusing :: Applicative f => LensLike (Rift (Yoneda f) (Yoneda f)) s t a b -> LensLike f s t a b
+confusing t = \f -> lowerYoneda . lowerRift . t (liftRiftYoneda . f)
+  where
+  liftRiftYoneda :: Applicative f => f a -> Rift (Yoneda f) (Yoneda f) a
+  liftRiftYoneda fa = Rift (`yap` fa)
+  {-# INLINE liftRiftYoneda #-}
+
+  yap :: Applicative f => Yoneda f (a -> b) -> f a -> Yoneda f b
+  yap (Yoneda k) fa = Yoneda (\ab_r -> k (ab_r .) <*> fa)
+  {-# INLINE yap #-}
+
+{-# INLINE confusing #-}
diff --git a/src/Control/Lens/Tuple.hs b/src/Control/Lens/Tuple.hs
--- a/src/Control/Lens/Tuple.hs
+++ b/src/Control/Lens/Tuple.hs
@@ -1,5 +1,6 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE Rank2Types #-}
+{-# LANGUAGE BangPatterns #-}
 {-# LANGUAGE TypeFamilies #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE EmptyDataDecls #-}
@@ -14,7 +15,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Tuple
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -33,6 +34,8 @@
   , Field7(..)
   , Field8(..)
   , Field9(..)
+  -- * Strict variations
+  , _1', _2', _3', _4', _5', _6', _7', _8', _9'
   ) where
 
 import Control.Applicative
@@ -384,6 +387,54 @@
 instance Field9 (a,b,c,d,e,f,g,h,i) (a,b,c,d,e,f,g,h,i') i i' where
   _9 k ~(a,b,c,d,e,f,g,h,i) = k i <&> \i' -> (a,b,c,d,e,f,g,h,i')
   {-# INLINE _9 #-}
+
+-- Strict versions of the _1 .. _9 operations
+
+-- | Strict version of '_1'
+_1' :: Field1 s t a b => Lens s t a b
+_1' = \f !x -> _1 f x
+{-# INLINE _1' #-}
+
+-- | Strict version of '_2'
+_2' :: Field2 s t a b => Lens s t a b
+_2' = \f !x -> _2 f x
+{-# INLINE _2' #-}
+
+-- | Strict version of '_3'
+_3' :: Field3 s t a b => Lens s t a b
+_3' = \f !x -> _3 f x
+{-# INLINE _3' #-}
+
+-- | Strict version of '_4'
+_4' :: Field4 s t a b => Lens s t a b
+_4' = \f !x -> _4 f x
+{-# INLINE _4' #-}
+
+-- | Strict version of '_5'
+_5' :: Field5 s t a b => Lens s t a b
+_5' = \f !x -> _5 f x
+{-# INLINE _5' #-}
+
+-- | Strict version of '_6'
+_6' :: Field6 s t a b => Lens s t a b
+_6' = \f !x -> _6 f x
+{-# INLINE _6' #-}
+
+-- | Strict version of '_7'
+_7' :: Field7 s t a b => Lens s t a b
+_7' = \f !x -> _7 f x
+{-# INLINE _7' #-}
+
+-- | Strict version of '_8'
+_8' :: Field8 s t a b => Lens s t a b
+_8' = \f !x -> _8 f x
+{-# INLINE _8' #-}
+
+-- | Strict version of '_9'
+_9' :: Field9 s t a b => Lens s t a b
+_9' = \f !x -> _9 f x
+{-# INLINE _9' #-}
+
 
 ix :: (Generic s, Generic t, GIxed n (Rep s) (Rep t) a b) => f n -> Lens s t a b
 ix n f = fmap to . gix n f . from
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 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Type
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -336,15 +336,15 @@
 --
 -- There are two laws that a 'Prism' should satisfy:
 --
--- First, if I 'Control.Lens.Review.re' or 'Control.Lens.Prism.review' a value with a 'Prism' and then 'Control.Lens.Fold.preview' or use ('Control.Lens.Fold.^?'), I will get it back:
+-- First, if I 'Control.Lens.Review.re' or 'Control.Lens.Review.review' a value with a 'Prism' and then 'Control.Lens.Fold.preview' or use ('Control.Lens.Fold.^?'), I will get it back:
 --
 -- @
--- 'Control.Lens.Fold.preview' l ('Control.Lens.Prism.review' l b) ≡ 'Just' b
+-- 'Control.Lens.Fold.preview' l ('Control.Lens.Review.review' l b) ≡ 'Just' b
 -- @
 --
 -- Second, if you can extract a value @a@ using a 'Prism' @l@ from a value @s@, then the value @s@ is completely described by @l@ and @a@:
 --
--- If @'Control.Lens.Fold.preview' l s ≡ 'Just' a@ then @'Control.Lens.Prism.review' l a ≡ s@
+-- If @'Control.Lens.Fold.preview' l s ≡ 'Just' a@ then @'Control.Lens.Review.review' l a ≡ s@
 --
 -- These two laws imply that the 'Traversal' laws hold for every 'Prism' and that we 'Data.Traversable.traverse' at most 1 element:
 --
diff --git a/src/Control/Lens/Wrapped.hs b/src/Control/Lens/Wrapped.hs
--- a/src/Control/Lens/Wrapped.hs
+++ b/src/Control/Lens/Wrapped.hs
@@ -16,7 +16,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Wrapped
--- Copyright   :  (C) 2012-14 Edward Kmett, Michael Sloan
+-- Copyright   :  (C) 2012-15 Edward Kmett, Michael Sloan
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -579,7 +579,7 @@
 failedAssertion (AssertionFailed x) = x
 {-# INLINE failedAssertion #-}
 
-getArrowMonad :: ArrowApply m  => ArrowMonad m a -> m () a
+getArrowMonad :: ArrowMonad m a -> m () a
 getArrowMonad (ArrowMonad x) = x
 {-# INLINE getArrowMonad #-}
 
diff --git a/src/Control/Lens/Zoom.hs b/src/Control/Lens/Zoom.hs
--- a/src/Control/Lens/Zoom.hs
+++ b/src/Control/Lens/Zoom.hs
@@ -16,7 +16,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Lens.Zoom
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -41,9 +41,7 @@
 import Control.Monad.Trans.RWS.Lazy as Lazy
 import Control.Monad.Trans.RWS.Strict as Strict
 import Control.Monad.Trans.Error
-#if MIN_VERSION_mtl(2,2,0)
 import Control.Monad.Trans.Except
-#endif
 import Control.Monad.Trans.List
 import Control.Monad.Trans.Identity
 import Control.Monad.Trans.Maybe
@@ -74,7 +72,7 @@
   -- 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
+  -- When applied to a 'Control.Lens.Traversal.Traversal'' over
   -- multiple values, the actions for each target are executed sequentially
   -- and the results are aggregated.
   --
@@ -150,11 +148,9 @@
   zoom l = ErrorT . liftM getErr . zoom (\afb -> unfocusingErr #. l (FocusingErr #. afb)) . liftM Err . runErrorT
   {-# INLINE zoom #-}
 
-#if MIN_VERSION_mtl(2,2,0)
 instance Zoom m n s t => Zoom (ExceptT e m) (ExceptT e n) s t where
   zoom l = ExceptT . liftM getErr . zoom (\afb -> unfocusingErr #. l (FocusingErr #. afb)) . liftM Err . runExceptT
   {-# INLINE zoom #-}
-#endif
 
 -- TODO: instance Zoom m m a a => Zoom (ContT r m) (ContT r m) a a where
 
diff --git a/src/Control/Monad/Error/Lens.hs b/src/Control/Monad/Error/Lens.hs
--- a/src/Control/Monad/Error/Lens.hs
+++ b/src/Control/Monad/Error/Lens.hs
@@ -4,7 +4,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Error.Lens
--- Copyright   :  (C) 2014 Edward Kmett
+-- Copyright   :  (C) 2014-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Control/Monad/Primitive/Lens.hs b/src/Control/Monad/Primitive/Lens.hs
--- a/src/Control/Monad/Primitive/Lens.hs
+++ b/src/Control/Monad/Primitive/Lens.hs
@@ -1,16 +1,10 @@
-{-# LANGUAGE CPP #-}
 {-# LANGUAGE MagicHash #-}
 {-# LANGUAGE UnboxedTuples #-}
 {-# LANGUAGE TypeFamilies #-}
-
-#ifndef MIN_VERSION_primitive
-#define MIN_VERSION_primitive(x,y,z) 1
-#endif
-
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Monad.Primitive.Lens
--- Copyright   :  (C) 2014 Edward Kmett
+-- Copyright   :  (C) 2014-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -23,15 +17,11 @@
   ) where
 
 import Control.Lens
-import Control.Monad.Primitive
+import Control.Monad.Primitive (PrimMonad(..))
 import GHC.Prim (State#)
 
 {-# ANN module "HLint: ignore Unused LANGUAGE pragma" #-}
 
-#if MIN_VERSION_primitive(0,6,0)
-prim :: PrimBase m => Iso' (m a) (State# (PrimState m) -> (# State# (PrimState m), a #))
-#else
-prim :: PrimMonad m => Iso' (m a) (State# (PrimState m) -> (# State# (PrimState m), a #))
-#endif
+prim :: (PrimMonad m) => Iso' (m a) (State# (PrimState m) -> (# State# (PrimState m), a #))
 prim = iso internal primitive
 {-# INLINE prim #-}
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
@@ -8,7 +8,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Parallel.Strategies.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
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
@@ -1,7 +1,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Control.Seq.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
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
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Array.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
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
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Bits.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/ByteString/Lazy/Lens.hs b/src/Data/ByteString/Lazy/Lens.hs
--- a/src/Data/ByteString/Lazy/Lens.hs
+++ b/src/Data/ByteString/Lazy/Lens.hs
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.ByteString.Lazy.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/ByteString/Lens.hs b/src/Data/ByteString/Lens.hs
--- a/src/Data/ByteString/Lens.hs
+++ b/src/Data/ByteString/Lens.hs
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.ByteString.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/ByteString/Strict/Lens.hs b/src/Data/ByteString/Strict/Lens.hs
--- a/src/Data/ByteString/Strict/Lens.hs
+++ b/src/Data/ByteString/Strict/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.ByteString.Strict.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -70,7 +70,7 @@
 -- Note that when just using this as a 'Setter', @'setting' 'Data.ByteString.map'@
 -- can be more efficient.
 bytes :: IndexedTraversal' Int ByteString Word8
-bytes = traversedStrictTree 0
+bytes = traversedStrictTree
 {-# INLINE bytes #-}
 
 -- | 'Data.ByteString.Char8.pack' (or 'Data.ByteString.Char8.unpack') a list of characters into a 'ByteString'
@@ -124,5 +124,5 @@
 -- >>> anyOf chars (== 'h') "hello"
 -- True
 chars :: IndexedTraversal' Int ByteString Char
-chars = traversedStrictTree8 0
+chars = traversedStrictTree8
 {-# INLINE chars #-}
diff --git a/src/Data/Complex/Lens.hs b/src/Data/Complex/Lens.hs
--- a/src/Data/Complex/Lens.hs
+++ b/src/Data/Complex/Lens.hs
@@ -1,12 +1,9 @@
 {-# LANGUAGE CPP #-}
 {-# LANGUAGE FlexibleContexts #-}
-#ifndef MIN_VERSION_base
-#define MIN_VERSION_base(x,y,z) 1
-#endif
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Complex.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -41,11 +38,7 @@
 -- a * 2 :+ b
 --
 -- @'_realPart' :: 'Functor' f => (a -> f a) -> 'Complex' a -> f ('Complex' a)@
-#if MIN_VERSION_base(4,4,0)
 _realPart :: Lens' (Complex a) a
-#else
-_realPart :: RealFloat a => Lens' (Complex a) a
-#endif
 _realPart f (a :+ b) = (:+ b) <$> f a
 {-# INLINE _realPart #-}
 
@@ -58,11 +51,7 @@
 -- a :+ b * 2
 --
 -- @'_imagPart' :: 'Functor' f => (a -> f a) -> 'Complex' a -> f ('Complex' a)@
-#if MIN_VERSION_base(4,4,0)
 _imagPart :: Lens' (Complex a) a
-#else
-_imagPart :: RealFloat a => Lens' (Complex a) a
-#endif
 _imagPart f (a :+ b) = (a :+) <$> f b
 {-# INLINE _imagPart #-}
 
diff --git a/src/Data/Data/Lens.hs b/src/Data/Data/Lens.hs
--- a/src/Data/Data/Lens.hs
+++ b/src/Data/Data/Lens.hs
@@ -17,7 +17,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Data.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett, (C) 2006-2012 Neil Mitchell
+-- Copyright   :  (C) 2012-2015 Edward Kmett, (C) 2006-2012 Neil Mitchell
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -401,7 +401,7 @@
 -------------------------------------------------------------------------------
 
 
-biplateData :: forall f s a. (Applicative f, Data s, Typeable a) => (forall c. Typeable c => c -> Answer c a) -> (a -> f a) -> s -> f s
+biplateData :: forall f s a. (Applicative f, Data s) => (forall c. Typeable c => c -> Answer c a) -> (a -> f a) -> s -> f s
 biplateData o f a0 = go2 a0 where
   go :: Data d => d -> f d
   go s = gfoldl (\x y -> x <*> go2 y) pure s
@@ -412,7 +412,7 @@
     Miss   -> pure s
 {-# INLINE biplateData #-}
 
-uniplateData :: forall f s a. (Applicative f, Data s, Typeable a) => (forall c. Typeable c => c -> Answer c a) -> (a -> f a) -> s -> f s
+uniplateData :: forall f s a. (Applicative f, Data s) => (forall c. Typeable c => c -> Answer c a) -> (a -> f a) -> s -> f s
 uniplateData o f a0 = go a0 where
   go :: Data d => d -> f d
   go s = gfoldl (\x y -> x <*> go2 y) pure s
diff --git a/src/Data/Dynamic/Lens.hs b/src/Data/Dynamic/Lens.hs
--- a/src/Data/Dynamic/Lens.hs
+++ b/src/Data/Dynamic/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Dynamic.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/HashSet/Lens.hs b/src/Data/HashSet/Lens.hs
--- a/src/Data/HashSet/Lens.hs
+++ b/src/Data/HashSet/Lens.hs
@@ -6,7 +6,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.HashSet.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -33,7 +33,7 @@
 --
 -- Sadly, you can't create a valid 'Traversal' for a 'Set', but you can
 -- manipulate it by reading using 'Control.Lens.Fold.folded' and reindexing it via 'setmapped'.
-setmapped :: (Eq i, Hashable i, Eq j, Hashable j) => IndexPreservingSetter (HashSet i) (HashSet j) i j
+setmapped :: (Eq j, Hashable j) => IndexPreservingSetter (HashSet i) (HashSet j) i j
 setmapped = setting HashSet.map
 {-# INLINE setmapped #-}
 
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
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.IntSet.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Data/List/Lens.hs b/src/Data/List/Lens.hs
--- a/src/Data/List/Lens.hs
+++ b/src/Data/List/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.List.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -16,9 +16,6 @@
   ( prefixed
   , suffixed
   , stripSuffix
-  -- * Deprecated
-  , strippingPrefix
-  , strippingSuffix
   ) where
 
 import Control.Monad (guard)
@@ -78,16 +75,3 @@
     go xs [] = zipWith const xs0 zs <$ guard (xs == qs)
     go [] _  = Nothing -- impossible
 {-# INLINE stripSuffix #-}
-
--- | This is a deprecated alias for 'prefixed'.
-strippingPrefix :: Eq a => [a] -> Prism' [a] [a]
-strippingPrefix = prefixed
-{-# INLINE strippingPrefix #-}
-{-# DEPRECATED strippingPrefix "Use 'prefixed'." #-}
-
--- | This is a deprecated alias for 'suffixed'.
-strippingSuffix :: Eq a => [a] -> Prism' [a] [a]
-strippingSuffix = suffixed
-{-# INLINE strippingSuffix #-}
-{-# DEPRECATED strippingSuffix "Use 'suffixed'." #-}
-
diff --git a/src/Data/List/Split/Lens.hs b/src/Data/List/Split/Lens.hs
deleted file mode 100644
--- a/src/Data/List/Split/Lens.hs
+++ /dev/null
@@ -1,199 +0,0 @@
-{-# LANGUAGE Rank2Types #-}
-----------------------------------------------------------------------------
--- |
--- Module      :  Data.List.Split.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett, Alexander Altman
--- License     :  BSD-style (see the file LICENSE)
--- Maintainer  :  Edward Kmett <ekmett@gmail.com>
--- Stability   :  provisional
--- Portability :  Rank2Types
---
--- Lenses for working with Data.List.Split
---
-----------------------------------------------------------------------------
-module Data.List.Split.Lens
-  (
-  -- * Splitting Folds
-    splitting
-  , splittingOn
-  , splittingOneOf
-  , splittingWhen
-  , endingBy
-  , endingByOneOf
-  , wordingBy
-  , liningBy
-  , chunking
-  , splittingPlaces
-  , splittingPlacesBlanks
-  -- * Lenses for 'Splitter' Internals
-  , delimiters
-  , delimiting
-  , condensing
-  , keepInitialBlanks
-  , keepFinalBlanks
-  ) where
-
-import Control.Lens
-import Data.Monoid
-import Data.List.Split
-import Data.List.Split.Internals
-
--- $setup
--- >>> :set -XNoOverloadedStrings
--- >>> import Control.Lens
--- >>> import Numeric.Lens (hex)
--- >>> import Data.Char (chr)
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' according to the given splitting strategy.
---
--- @
--- 'splitting' :: 'Splitter' a -> 'Fold' s a -> 'Fold' s [a]
--- @
-splitting :: Splitter a -> Getting (Endo [a]) s a -> Fold s [a]
-splitting s l f = coerce . traverse f . split s . toListOf l
-{-# INLINE splitting #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' on the given delimiter.
---
--- Equivalent to @'splitting' '.' 'dropDelims' '.' 'onSublist'@.
---
--- @
--- 'splittingOn' :: 'Eq' a => [a] -> 'Fold' s a -> 'Fold' s [a]
--- @
-splittingOn :: Eq a => [a] -> Getting (Endo [a]) s a -> Fold s [a]
-splittingOn s l f = coerce . traverse f . splitOn s . toListOf l
-{-# INLINE splittingOn #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' on any of the given elements.
---
--- Equivalent to @'splitting' '.' 'dropDelims' '.' 'oneOf'@.
---
--- @
--- 'splittingOn' :: 'Eq' a => [a] -> 'Fold' s a -> 'Fold' s [a]
--- @
-splittingOneOf :: Eq a => [a] -> Getting (Endo [a]) s a -> Fold s [a]
-splittingOneOf s l f = coerce . traverse f . splitOneOf s . toListOf l
-{-# INLINE splittingOneOf #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' on elements satisfying the given predicate.
---
--- Equivalent to @'splitting' '.' 'dropDelims' '.' 'whenElt'@.
---
--- @
--- 'splittingWhen' :: (a -> 'Bool') -> 'Fold' s a -> 'Fold' s [a]
--- @
-splittingWhen :: (a -> Bool) -> Getting (Endo [a]) s a -> Fold s [a]
-splittingWhen s l f = coerce . traverse f . splitWhen s . toListOf l
-{-# INLINE splittingWhen #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into chunks terminated by the given delimiter.
---
--- Equivalent to @'splitting' '.' 'dropDelims' '.' 'onSublist'@.
---
--- @
--- 'endingBy' :: 'Eq' a => [a] -> 'Fold' s a -> 'Fold' s [a]
--- @
-endingBy :: Eq a => [a] -> Getting (Endo [a]) s a -> Fold s [a]
-endingBy s l f = coerce . traverse f . endBy s . toListOf l
-{-# INLINE endingBy #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into chunks terminated by any of the given elements.
---
--- Equivalent to @'splitting' '.' 'dropFinalBlank' '.' 'dropDelims' '.' 'oneOf'@.
---
--- @
--- 'endingByOneOf' :: 'Eq' a => [a] -> 'Fold' s a -> 'Fold' s [a]
--- @
-endingByOneOf :: Eq a => [a] -> Getting (Endo [a]) s a -> Fold s [a]
-endingByOneOf s l f = coerce . traverse f . endByOneOf s . toListOf l
-{-# INLINE endingByOneOf #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into "words", with word boundaries indicated by the given predicate.
---
--- Equivalent to @'splitting' '.' 'dropBlanks' '.' 'dropDelims' '.' 'whenElt'@.
---
--- @
--- 'wordingBy' :: (a -> 'Bool') -> 'Fold' s a -> 'Fold' s [a]
--- @
-wordingBy :: (a -> Bool) -> Getting (Endo [a]) s a -> Fold s [a]
-wordingBy s l f = coerce . traverse f . wordsBy s . toListOf l
-{-# INLINE wordingBy #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into "lines", with line boundaries indicated by the given predicate.
---
--- Equivalent to @'splitting' '.' 'dropFinalBlank' '.' 'dropDelims' '.' 'whenElt'@.
---
--- @
--- 'liningBy' :: (a -> 'Bool') -> 'Fold' s a -> 'Fold' s [a]
--- @
-liningBy :: (a -> Bool) -> Getting (Endo [a]) s a -> Fold s [a]
-liningBy s l f = coerce . traverse f . linesBy s . toListOf l
-{-# INLINE liningBy #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into length-@n@ pieces.
---
--- >>> "48656c6c6f20776f726c64"^..chunking 2 folded.hex.to chr
--- "Hello world"
---
--- @
--- 'chunking' :: 'Int' -> 'Fold' s a -> 'Fold' s [a]
--- @
-chunking :: Int -- ^ @n@
-            -> Getting (Endo [a]) s a -> Fold s [a]
-chunking s l f = coerce . traverse f . chunksOf s . toListOf l
-{-# INLINE chunking #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into chunks of the given lengths, .
---
--- @
--- 'splittingPlaces' :: 'Integral' n => [n] -> 'Fold' s a -> 'Fold' s [a]
--- @
-splittingPlaces :: Integral n => [n] -> Getting (Endo [a]) s a -> Fold s [a]
-splittingPlaces s l f = coerce . traverse f . splitPlaces s . toListOf l
-{-# INLINE splittingPlaces #-}
-
--- | Obtain a 'Fold' by splitting another 'Fold', 'Lens', 'Getter' or 'Traversal' into chunks of the given lengths.  Unlike 'splittingPlaces', the output 'Fold' will always be the same length as the first input argument.
---
--- @
--- 'splittingPlacesBlanks' :: 'Integral' n => [n] -> 'Fold' s a -> 'Fold' s [a]
--- @
-splittingPlacesBlanks :: Integral n => [n] -> Getting (Endo [a]) s a -> Fold s [a]
-splittingPlacesBlanks s l f = coerce . traverse f . splitPlacesBlanks s . toListOf l
-{-# INLINE splittingPlacesBlanks #-}
-
--- | Modify or retrieve the list of delimiters for a 'Splitter'.
-delimiters :: Lens (Splitter a) (Splitter b) [a -> Bool] [b -> Bool]
-delimiters f s@Splitter { delimiter = Delimiter ds } = f ds <&> \ds' -> s { delimiter = Delimiter ds' }
-{-# INLINE delimiters #-}
-
--- | Modify or retrieve the policy for what a 'Splitter' should do with delimiters.
-delimiting :: Lens' (Splitter a) DelimPolicy
-delimiting f s@Splitter { delimPolicy = p } = f p <&> \p' -> s { delimPolicy = p' }
-{-# INLINE delimiting #-}
-
--- | Modify or retrieve the policy for what a 'Splitter' should do about consecutive delimiters.
-condensing :: Lens' (Splitter a) CondensePolicy
-condensing f s@Splitter { condensePolicy = p } = f p <&> \p' -> s { condensePolicy = p' }
-{-# INLINE condensing #-}
-
--- | Modify or retrieve the policy for whether a 'Splitter' should drop an initial blank.
-keepInitialBlanks :: Lens' (Splitter a) Bool
-keepInitialBlanks f s@Splitter { initBlankPolicy = p } = f (keeps p) <&> \p' -> s { initBlankPolicy = end p' }
-{-# INLINE keepInitialBlanks #-}
-
--- | Modify or retrieve the policy for whether a 'Splitter' should drop a final blank.
-keepFinalBlanks :: Lens' (Splitter a) Bool
-keepFinalBlanks f s@Splitter { finalBlankPolicy = p } = f (keeps p) <&> \p' -> s { finalBlankPolicy = end p' }
-{-# INLINE keepFinalBlanks #-}
-
--- utilities
-
-end :: Bool -> EndPolicy
-end True  = KeepBlank
-end False = DropBlank
-{-# INLINE end #-}
-
-keeps :: EndPolicy -> Bool
-keeps KeepBlank = True
-keeps DropBlank = False
-{-# INLINE keeps #-}
diff --git a/src/Data/Map/Lens.hs b/src/Data/Map/Lens.hs
--- a/src/Data/Map/Lens.hs
+++ b/src/Data/Map/Lens.hs
@@ -1,4 +1,12 @@
--- | One of most commonly-asked questions about this package is whether
+-----------------------------------------------------------------------------
+-- |
+-- Copyright   :  (C) 2014-2015 Edward Kmett
+-- License     :  BSD-style (see the file LICENSE)
+-- Maintainer  :  Edward Kmett <ekmett@gmail.com>
+-- Stability   :  experimental
+-- Portability :  non-portable
+--
+-- One of most commonly-asked questions about this package is whether
 -- it provides lenses for working with 'Data.Map.Map'. It does, but their uses
 -- are perhaps obscured by their genericity. This module exists to provide
 -- documentation for them.
@@ -50,6 +58,8 @@
 --
 -- >>> preview traverseMax $ Map.fromList [(5, "Saturn"), (6, "Uranus")]
 -- Just "Uranus"
+--
+-----------------------------------------------------------------------------
 module Data.Map.Lens () where
 -- $setup
 -- >>> import Control.Lens
diff --git a/src/Data/Sequence/Lens.hs b/src/Data/Sequence/Lens.hs
--- a/src/Data/Sequence/Lens.hs
+++ b/src/Data/Sequence/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Sequence.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
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
@@ -1,8 +1,13 @@
+{-# LANGUAGE CPP #-}
 {-# LANGUAGE Rank2Types #-}
+
+#ifndef MIN_VERSION_containers
+#define MIN_VERSION_containers(x,y,z) 1
+#endif
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Set.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -32,7 +37,11 @@
 --
 -- >>> over setmapped (+1) (fromList [1,2,3,4])
 -- fromList [2,3,4,5]
+#if MIN_VERSION_containers(0,5,2)
+setmapped :: Ord j => IndexPreservingSetter (Set i) (Set j) i j
+#else
 setmapped :: (Ord i, Ord j) => IndexPreservingSetter (Set i) (Set j) i j
+#endif
 setmapped = setting Set.map
 {-# INLINE setmapped #-}
 
diff --git a/src/Data/Text/Lazy/Lens.hs b/src/Data/Text/Lazy/Lens.hs
--- a/src/Data/Text/Lazy/Lens.hs
+++ b/src/Data/Text/Lazy/Lens.hs
@@ -4,7 +4,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Text.Lazy.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/Text/Lens.hs b/src/Data/Text/Lens.hs
--- a/src/Data/Text/Lens.hs
+++ b/src/Data/Text/Lens.hs
@@ -5,7 +5,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Text.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/Text/Strict/Lens.hs b/src/Data/Text/Strict/Lens.hs
--- a/src/Data/Text/Strict/Lens.hs
+++ b/src/Data/Text/Strict/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Text.Strict.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/Tree/Lens.hs b/src/Data/Tree/Lens.hs
--- a/src/Data/Tree/Lens.hs
+++ b/src/Data/Tree/Lens.hs
@@ -2,7 +2,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Tree.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/Data/Typeable/Lens.hs b/src/Data/Typeable/Lens.hs
--- a/src/Data/Typeable/Lens.hs
+++ b/src/Data/Typeable/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Typeable.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Data/Vector/Generic/Lens.hs b/src/Data/Vector/Generic/Lens.hs
--- a/src/Data/Vector/Generic/Lens.hs
+++ b/src/Data/Vector/Generic/Lens.hs
@@ -7,7 +7,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Vector.Generic.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -24,6 +24,7 @@
   , asStream
   , asStreamR
   , cloned
+  , converted
   -- * Lenses
   , sliced
   -- * Traversal of individual indices
@@ -33,7 +34,7 @@
 
 import Control.Applicative
 import Control.Lens
-import Data.List (nub)
+import Control.Lens.Internal.List (ordinalNub)
 import Data.Monoid
 import Data.Vector.Generic as V hiding (zip, filter, indexed)
 import Data.Vector.Fusion.Stream (Stream)
@@ -79,18 +80,18 @@
 --
 -- >>> Vector.fromList [0,8,15] ^. from vector
 -- [0,8,15]
-vector :: Vector v a => Iso' [a] (v a)
+vector :: (Vector v a, Vector v b) => Iso [a] [b] (v a) (v b)
 vector = iso fromList V.toList
 {-# INLINE vector #-}
 
 -- | Convert a 'Vector' to a finite 'Stream' (or back.)
-asStream :: Vector v a => Iso' (v a) (Stream a)
+asStream :: (Vector v a, Vector v b) => Iso (v a) (v b) (Stream a) (Stream b)
 asStream = iso stream unstream
 {-# INLINE asStream #-}
 
 -- | Convert a 'Vector' to a finite 'Stream' from right to left (or
 -- back.)
-asStreamR :: Vector v a => Iso' (v a) (Stream a)
+asStreamR :: (Vector v a, Vector v b) => Iso (v a) (v b) (Stream a) (Stream b)
 asStreamR = iso streamR unstreamR
 {-# INLINE asStreamR #-}
 
@@ -112,8 +113,7 @@
 -- >>> toListOf (ordinals [1,3,2,5,9,10]) $ Vector.fromList [2,4..40]
 -- [4,8,6,12,20,22]
 ordinals :: Vector v a => [Int] -> IndexedTraversal' Int (v a) a
-ordinals is f v = fmap (v //) $ traverse (\i -> (,) i <$> indexed f i (v ! i)) $ nub $ filter (\i -> 0 <= i && i < l) is where
-  l = length v
+ordinals is f v = fmap (v //) $ traverse (\i -> (,) i <$> indexed f i (v ! i)) $ ordinalNub (length v) is
 {-# INLINE ordinals #-}
 
 -- | Like 'ix' but polymorphic in the vector type.
@@ -122,3 +122,7 @@
   | 0 <= i && i < V.length v = f (v V.! i) <&> \a -> v V.// [(i, a)]
   | otherwise                = pure v
 {-# INLINE vectorIx #-}
+
+-- | Different vector implementations are isomorphic to each other.
+converted :: (Vector v a, Vector w a, Vector v b, Vector w b) => Iso (v a) (v b) (w a) (w b)
+converted = iso convert convert
diff --git a/src/Data/Vector/Lens.hs b/src/Data/Vector/Lens.hs
--- a/src/Data/Vector/Lens.hs
+++ b/src/Data/Vector/Lens.hs
@@ -8,7 +8,7 @@
 -------------------------------------------------------------------------------
 -- |
 -- Module      :  Data.Vector.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
@@ -30,9 +30,9 @@
 
 import Control.Applicative
 import Control.Lens
+import Control.Lens.Internal.List (ordinalNub)
 import Data.Vector as Vector hiding (zip, filter, indexed)
 import Prelude hiding ((++), length, null, head, tail, init, last, map, reverse)
-import Data.List (nub)
 import Data.Monoid
 
 -- | @sliced i n@ provides a 'Lens' that edits the @n@ elements starting
@@ -89,7 +89,5 @@
 -- >>> toListOf (ordinals [1,3,2,5,9,10]) $ Vector.fromList [2,4..40]
 -- [4,8,6,12,20,22]
 ordinals :: [Int] -> IndexedTraversal' Int (Vector a) a
-ordinals is f v = fmap (v //) $ traverse (\i -> (,) i <$> indexed f i (v ! i)) $ nub $ filter (\i -> 0 <= i && i < l) is where
-  l = length v
+ordinals is f v = fmap (v //) $ traverse (\i -> (,) i <$> indexed f i (v ! i)) $ ordinalNub (length v) is
 {-# INLINE ordinals #-}
-
diff --git a/src/GHC/Generics/Lens.hs b/src/GHC/Generics/Lens.hs
--- a/src/GHC/Generics/Lens.hs
+++ b/src/GHC/Generics/Lens.hs
@@ -6,7 +6,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  GHC.Generics.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Generics/Deriving/Lens.hs b/src/Generics/Deriving/Lens.hs
--- a/src/Generics/Deriving/Lens.hs
+++ b/src/Generics/Deriving/Lens.hs
@@ -2,10 +2,11 @@
 {-# LANGUAGE Rank2Types #-}
 {-# LANGUAGE TypeOperators #-}
 {-# LANGUAGE FlexibleContexts #-}
+{-# LANGUAGE UndecidableInstances #-}
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Generics.Deriving.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Language/Haskell/TH/Lens.hs b/src/Language/Haskell/TH/Lens.hs
--- a/src/Language/Haskell/TH/Lens.hs
+++ b/src/Language/Haskell/TH/Lens.hs
@@ -10,7 +10,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  Language.Haskell.TH.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/src/Numeric/Lens.hs b/src/Numeric/Lens.hs
--- a/src/Numeric/Lens.hs
+++ b/src/Numeric/Lens.hs
@@ -2,7 +2,7 @@
 --------------------------------------------------------------------------------
 -- |
 -- Module      :  Numeric.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/System/Exit/Lens.hs b/src/System/Exit/Lens.hs
--- a/src/System/Exit/Lens.hs
+++ b/src/System/Exit/Lens.hs
@@ -3,7 +3,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  System.Exit.Lens
--- Copyright   :  (C) 2013-14 Edward Kmett
+-- Copyright   :  (C) 2013-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  provisional
diff --git a/src/System/FilePath/Lens.hs b/src/System/FilePath/Lens.hs
--- a/src/System/FilePath/Lens.hs
+++ b/src/System/FilePath/Lens.hs
@@ -1,7 +1,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  System.FilePath.Lens
--- Copyright   :  (C) 2012-14 Edward Kmett
+-- Copyright   :  (C) 2012-15 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
@@ -50,7 +50,7 @@
 {-# INLINE (</>~) #-}
 
 
--- | Modify the target(s) of a 'Simple' 'Lens', 'Iso', 'Setter' or 'Traversal' by adding a path.
+-- | Modify the target(s) of a 'Lens'', 'Iso'', 'Setter'' or 'Traversal'' by adding a path.
 --
 -- >>> execState (both </>= "bin") ("hello","world")
 -- ("hello/bin","world/bin")
@@ -106,7 +106,7 @@
 l <.>~ n = over l (<.> n)
 {-# INLINE (<.>~) #-}
 
--- | Modify the target(s) of a 'Simple' 'Lens', 'Iso', 'Setter' or 'Traversal' by adding an extension.
+-- | Modify the target(s) of a 'Lens'', 'Iso'', 'Setter'' or 'Traversal'' by adding an extension.
 --
 -- >>> execState (both <.>= "txt") ("hello","world")
 -- ("hello.txt","world.txt")
diff --git a/src/System/IO/Error/Lens.hs b/src/System/IO/Error/Lens.hs
--- a/src/System/IO/Error/Lens.hs
+++ b/src/System/IO/Error/Lens.hs
@@ -4,7 +4,7 @@
 -----------------------------------------------------------------------------
 -- |
 -- Module      :  System.IO.Error.Lens
--- Copyright   :  (C) 2012-2014 Edward Kmett
+-- Copyright   :  (C) 2012-2015 Edward Kmett
 -- License     :  BSD-style (see the file LICENSE)
 -- Maintainer  :  Edward Kmett <ekmett@gmail.com>
 -- Stability   :  experimental
diff --git a/tests/properties.hs b/tests/properties.hs
--- a/tests/properties.hs
+++ b/tests/properties.hs
@@ -70,7 +70,7 @@
 prop__Just                           = isPrism (_Just :: Prism' (Maybe Int) Int)
 
 -- Data.List.Lens
-prop_strippingPrefix s               = isPrism (strippingPrefix s :: Prism' String String)
+prop_prefixed s                      = isPrism (prefixed s :: Prism' String String)
 
 -- Data.Text.Lens
 prop_text s                          = s^.packed.from packed == s