diff --git a/.travis.yml b/.travis.yml
--- a/.travis.yml
+++ b/.travis.yml
@@ -45,7 +45,7 @@
 
 install:
   - $CABAL install --dependencies-only --enable-tests
-  - $CABAL configure -flib-Werror --enable-tests $MODE
+  - $CABAL configure --enable-tests $MODE
 
 script:
   - $CABAL build
diff --git a/CHANGELOG.markdown b/CHANGELOG.markdown
--- a/CHANGELOG.markdown
+++ b/CHANGELOG.markdown
@@ -1,3 +1,9 @@
+4.10
+----
+* Added `elemIndexOf`, `elemIndicesOf`, `findIndexOf`, and `findIndicesOf`.
+* Fixed `Ixed` instance for `Tree`. It no longer drops nodes prior to the traversed node.
+* `bifunctors` 5, `profunctors` 5 and `semigroupoids` 5 support.
+
 4.9.1
 -----
 * Added `_Wrapped` support for `NonEmpty`.
diff --git a/README.markdown b/README.markdown
--- a/README.markdown
+++ b/README.markdown
@@ -349,13 +349,6 @@
   <td/><td/><td/>
   <td>Return a list of the target(s)</td>
 </tr>
-<tr>
-  <td><a href="http://ekmett.github.com/lens/Control-Lens-Action.html#v:perform"><code>perform</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-Action.html#v:performs"><code>performs</code></a><a href="http://ekmett.github.com/lens/Control-Lens-Action.html#v:-94-!"><code>^!</code></a></td>
-  <td/>
-  <td/>
-  <td/>
-  <td>Perform monadic action(s)</td>
-</tr>
 <tr><th colspan=5><a href="http://ekmett.github.com/lens/Control-Lens.html">Control.Lens</a> (Indexed)</th></tr>
 <tr>
   <td><a href="http://ekmett.github.com/lens/Control-Lens-IndexedSetter.html#v:iover"><code>iover</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-IndexedSetter.html#v:imapOf"><code>imapOf</code></a>,<a href="http://ekmett.github.com/lens/Control-Lens-IndexedSetter.html#v:-37--64--126-"><code>%@~</code></a></td>
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.9.1
+version:       4.10
 license:       BSD3
 cabal-version: >= 1.8
 license-file:  LICENSE
@@ -12,7 +12,7 @@
 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
+tested-with:   GHC == 7.4.2, GHC == 7.6.3, GHC == 7.8.4, GHC == 7.10.1
 synopsis:      Lenses, Folds and Traversals
 description:
   This package comes \"Batteries Included\" with many useful lenses for the types
@@ -170,10 +170,6 @@
   default: True
   manual: True
 
-flag lib-Werror
-  default: False
-  manual: True
-
 -- Attempt a parallel build with GHC 7.8
 flag j
   default: False
@@ -183,7 +179,7 @@
   build-depends:
     array                     >= 0.3.0.2  && < 0.6,
     base                      >= 4.5      && < 5,
-    bifunctors                >= 4        && < 5,
+    bifunctors                >= 5        && < 6,
     bytestring                >= 0.9.1.10 && < 0.11,
     comonad                   >= 4        && < 5,
     contravariant             >= 0.3      && < 2,
@@ -197,9 +193,9 @@
     exceptions                >= 0.1.1    && < 1,
     mtl                       >= 2.0.1    && < 2.3,
     parallel                  >= 3.1.0.1  && < 3.3,
-    profunctors               >= 4        && < 5,
+    profunctors               >= 5        && < 6,
     reflection                >= 1.1.6    && < 2,
-    semigroupoids             >= 4        && < 5,
+    semigroupoids             >= 5        && < 6,
     semigroups                >= 0.8.4    && < 1,
     tagged                    >= 0.4.4    && < 1,
     template-haskell          >= 2.4      && < 2.11,
@@ -310,9 +306,6 @@
 
   if flag(inlining)
     cpp-options: -DINLINING
-
-  if flag(lib-Werror)
-    ghc-options: -Werror
 
   if impl(ghc<7.4)
     ghc-options: -fno-spec-constr-count
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
@@ -219,11 +219,9 @@
 instance Ixed (Tree a) where
   ix xs0 f = go xs0 where
     go [] (Node a as) = f a <&> \a' -> Node a' as
-    go (i:is) t@(Node a as) | i < 0     = pure t
-                            | otherwise = Node a <$> goto is as i
-    goto is (a:as) 0 = go is a <&> (:as)
-    goto is (_:as) n = goto is as $! n - 1
-    goto _  []     _ = pure []
+    go (i:is) t@(Node a as)
+      | i < 0     = pure t
+      | otherwise = Node a <$> ix i (go is) as
   {-# INLINE ix #-}
 
 type instance IxValue (Seq a) = a
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
@@ -113,6 +113,10 @@
   , ifoldrMOf
   , ifoldlMOf
   , itoListOf
+  , elemIndexOf
+  , elemIndicesOf
+  , findIndexOf
+  , findIndicesOf
 
   -- ** Building Indexed Folds
   , ifiltered
@@ -153,6 +157,7 @@
 import Data.Monoid
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Data.Traversable
 import Prelude
@@ -342,7 +347,7 @@
 -- which is not a 'Traversal' per the laws, unless you are careful to ensure that you do not invalidate the predicate when
 -- writing back through it.
 takingWhile :: (Conjoined p, Applicative f) => (a -> Bool) -> Over p (TakingWhile p f a a) s t a a -> Over p f s t a a
-takingWhile p l pafb = fmap runMagma . traverse (corep pafb) . runTakingWhile . l flag where
+takingWhile p l pafb = fmap runMagma . traverse (cosieve pafb) . runTakingWhile . l flag where
   flag = cotabulate $ \wa -> let a = extract wa; r = p a in TakingWhile r a $ \pr ->
     if pr && r then Magma () wa else MagmaPure a
 {-# INLINE takingWhile #-}
@@ -394,7 +399,7 @@
   g = cotabulate $ \wa -> Compose $ state $ \b -> let
       a = extract wa
       b' = b && p a
-    in (if b' then pure a else corep f wa, b')
+    in (if b' then pure a else cosieve f wa, b')
 {-# INLINE droppingWhile #-}
 
 -- | A 'Fold' over the individual 'words' of a 'String'.
@@ -1432,7 +1437,7 @@
 -- 'findOf' l p = 'foldrOf' l (\a y -> if p a then 'Just' a else y) 'Nothing'
 -- @
 findOf :: Conjoined p => Accessing p (Endo (Maybe a)) s a -> p a Bool -> s -> Maybe a
-findOf l p = foldrOf l (cotabulate $ \wa y -> if corep p wa then Just (extract wa) else y) Nothing
+findOf l p = foldrOf l (cotabulate $ \wa y -> if cosieve p wa then Just (extract wa) else y) Nothing
 {-# INLINE findOf #-}
 
 -- | The 'findMOf' function takes a 'Lens' (or 'Getter', 'Iso', 'Fold', or 'Traversal'),
@@ -1472,7 +1477,7 @@
 -- 'findMOf' l p = 'foldrOf' l (\a y -> p a >>= \x -> if x then return ('Just' a) else y) $ return 'Nothing'
 -- @
 findMOf :: (Monad m, Conjoined p) => Accessing p (Endo (m (Maybe a))) s a -> p a (m Bool) -> s -> m (Maybe a)
-findMOf l p = foldrOf l (cotabulate $ \wa y -> corep p wa >>= \r -> if r then return (Just (extract wa)) else y) $ return Nothing
+findMOf l p = foldrOf l (cotabulate $ \wa y -> cosieve p wa >>= \r -> if r then return (Just (extract wa)) else y) $ return Nothing
 {-# INLINE findMOf #-}
 
 -- | A variant of 'foldrOf' that has no base case and thus may only be applied
@@ -2339,6 +2344,62 @@
 (^@?!) :: s -> IndexedGetting i (Endo (i, a)) s a -> (i, a)
 s ^@?! l = ifoldrOf l (\i x _ -> (i,x)) (error "(^@?!): empty Fold") s
 {-# INLINE (^@?!) #-}
+
+-- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which is equal to a given value.
+--
+-- @
+-- 'Data.List.elemIndex' ≡ 'elemIndexOf' 'folded'
+-- @
+--
+-- @
+-- 'elemIndexOf' :: 'Eq' a => 'IndexedFold' i s a       -> a -> s -> 'Maybe' i
+-- 'elemIndexOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> 'Maybe' i
+-- @
+elemIndexOf :: Eq a => IndexedGetting i (First i) s a -> a -> s -> Maybe i
+elemIndexOf l a = findIndexOf l (a ==)
+{-# INLINE elemIndexOf #-}
+
+-- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which are equal to a given value.
+--
+-- @
+-- 'Data.List.elemIndices' ≡ 'elemIndicesOf' 'folded'
+-- @
+--
+-- @
+-- 'elemIndicesOf' :: 'Eq' a => 'IndexedFold' i s a       -> a -> s -> [i]
+-- 'elemIndicesOf' :: 'Eq' a => 'IndexedTraversal'' i s a -> a -> s -> [i]
+-- @
+elemIndicesOf :: Eq a => IndexedGetting i (Endo [i]) s a -> a -> s -> [i]
+elemIndicesOf l a = findIndicesOf l (a ==)
+{-# INLINE elemIndicesOf #-}
+
+-- | Retrieve the index of the first value targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfies a predicate.
+--
+-- @
+-- 'Data.List.findIndex' ≡ 'findIndexOf' 'folded'
+-- @
+--
+-- @
+-- 'findIndexOf' :: 'IndexedFold' i s a       -> (a -> 'Bool') -> s -> 'Maybe' i
+-- 'findIndexOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> 'Maybe' i
+-- @
+findIndexOf :: IndexedGetting i (First i) s a -> (a -> Bool) -> s -> Maybe i
+findIndexOf l p = preview (l . filtered p . asIndex)
+{-# INLINE findIndexOf #-}
+
+-- | Retrieve the indices of the values targeted by a 'IndexedFold' or 'IndexedTraversal' which satisfy a predicate.
+--
+-- @
+-- 'Data.List.findIndices' ≡ 'findIndicesOf' 'folded'
+-- @
+--
+-- @
+-- 'findIndicesOf' :: 'IndexedFold' i s a       -> (a -> 'Bool') -> s -> [i]
+-- 'findIndicesOf' :: 'IndexedTraversal'' i s a -> (a -> 'Bool') -> s -> [i]
+-- @
+findIndicesOf :: IndexedGetting i (Endo [i]) s a -> (a -> Bool) -> s -> [i]
+findIndicesOf l p = toListOf (l . filtered p . asIndex)
+{-# INLINE findIndicesOf #-}
 
 -------------------------------------------------------------------------------
 -- Converting to Folds
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
@@ -181,24 +181,6 @@
 {-# INLINE icompose #-}
 
 -------------------------------------------------------------------------------
--- Converting to Folds
--------------------------------------------------------------------------------
-
--- | Fold a container with indices returning both the indices and the values.
---
--- The result is only valid to compose in a 'Traversal', if you don't edit the
--- index as edits to the index have no effect.
-withIndex :: (Indexable i p, Functor f) => Optical p (Indexed i) f s t (i, s) (j, t)
-withIndex f = Indexed $ \i a -> snd <$> indexed f i (i, a)
-{-# INLINE withIndex #-}
-
--- | When composed with an 'IndexedFold' or 'IndexedTraversal' this yields an
--- ('Indexed') 'Fold' of the indices.
-asIndex :: (Indexable i p, Contravariant f, Functor f) => Optical' p (Indexed i) f s i
-asIndex f = Indexed $ \i _ -> coerce (indexed f i i)
-{-# INLINE asIndex #-}
-
--------------------------------------------------------------------------------
 -- Restricting by index
 -------------------------------------------------------------------------------
 
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
@@ -39,6 +39,7 @@
 import Data.Semigroup
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Prelude hiding ((.),id)
 
@@ -91,7 +92,7 @@
   {-# INLINE iduplicate #-}
 
 instance Corepresentable p => Sellable p (Bazaar p) where
-  sell = cotabulate $ \ w -> Bazaar $ tabulate $ \k -> pure (corep k w)
+  sell = cotabulate $ \ w -> Bazaar $ tabulate $ \k -> pure (cosieve k w)
   {-# INLINE sell #-}
 
 instance Profunctor p => Bizarre p (Bazaar p) where
@@ -154,7 +155,7 @@
   {-# INLINE iduplicate #-}
 
 instance Corepresentable p => Sellable p (BazaarT p g) where
-  sell = cotabulate $ \ w -> BazaarT (`corep` w)
+  sell = cotabulate $ \ w -> BazaarT (`cosieve` w)
   {-# INLINE sell #-}
 
 instance Profunctor p => Bizarre p (BazaarT p g) where
@@ -247,7 +248,7 @@
   {-# INLINE iduplicate #-}
 
 instance Corepresentable p => Sellable p (Bazaar1 p) where
-  sell = cotabulate $ \ w -> Bazaar1 $ tabulate $ \k -> pure (corep k w)
+  sell = cotabulate $ \ w -> Bazaar1 $ tabulate $ \k -> pure (cosieve k w)
   {-# INLINE sell #-}
 
 instance Profunctor p => Bizarre1 p (Bazaar1 p) where
@@ -304,7 +305,7 @@
   {-# INLINE iduplicate #-}
 
 instance Corepresentable p => Sellable p (BazaarT1 p g) where
-  sell = cotabulate $ \ w -> BazaarT1 (`corep` w)
+  sell = cotabulate $ \ w -> BazaarT1 (`cosieve` w)
   {-# INLINE sell #-}
 
 instance Profunctor p => Bizarre1 p (BazaarT1 p g) where
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
@@ -40,6 +40,7 @@
 import Data.Functor.Identity
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Prelude hiding ((.),id)
 
@@ -266,7 +267,7 @@
   {-# INLINE experiment #-}
 
 instance Corepresentable p => Sellable p (Pretext p) where
-  sell = cotabulate $ \ w -> Pretext (`corep` w)
+  sell = cotabulate $ \ w -> Pretext (`cosieve` w)
   {-# INLINE sell #-}
 
 ------------------------------------------------------------------------------
@@ -346,7 +347,7 @@
   {-# INLINE experiment #-}
 
 instance Corepresentable p => Sellable p (PretextT p g) where
-  sell = cotabulate $ \ w -> PretextT (`corep` w)
+  sell = cotabulate $ \ w -> PretextT (`cosieve` w)
   {-# INLINE sell #-}
 
 instance (Profunctor p, Contravariant g) => Contravariant (PretextT p g a b) where
@@ -360,5 +361,5 @@
 -- | We can convert any 'Conjoined' 'Profunctor' to a function,
 -- possibly losing information about an index in the process.
 coarr :: (Representable q, Comonad (Rep q)) => q a b -> a -> b
-coarr qab = extract . rep qab
+coarr qab = extract . sieve qab
 {-# INLINE coarr #-}
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
@@ -29,6 +29,9 @@
   -- * 64-bit Indexing
   , Indexing64(..)
   , indexing64
+  -- * Converting to Folds
+  , withIndex
+  , asIndex
   ) where
 
 import Control.Applicative
@@ -36,6 +39,7 @@
 import Control.Category
 import Control.Comonad
 import Control.Lens.Internal.Instances ()
+import qualified Control.Lens.Internal.Getter as Getter
 import Control.Monad
 import Control.Monad.Fix
 import Data.Distributive
@@ -44,6 +48,7 @@
 import Data.Int
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Traversable
 import Prelude hiding ((.),id)
 #ifndef SAFE
@@ -68,7 +73,7 @@
   -- 'Profunctor' over every Haskell 'Functor'. This is effectively a
   -- generalization of 'fmap'.
   distrib :: Functor f => p a b -> p (f a) (f b)
-  distrib = tabulate . collect . rep
+  distrib = tabulate . collect . sieve
   {-# INLINE distrib #-}
 
   -- | This permits us to make a decision at an outermost point about whether or not we use an index.
@@ -151,20 +156,24 @@
   {-# INLINE ( #. ) #-}
 #endif
 
-instance Corepresentable (Indexed i) where
-  type Corep (Indexed i) = (,) i
-  cotabulate = Indexed . curry
-  {-# INLINE cotabulate #-}
-  corep = uncurry . runIndexed
-  {-# INLINE corep #-}
+instance Sieve (Indexed i) ((->) i) where
+  sieve = flip . runIndexed
+  {-# INLINE sieve #-}
 
 instance Representable (Indexed i) where
   type Rep (Indexed i) = (->) i
   tabulate = Indexed . flip
   {-# INLINE tabulate #-}
-  rep = flip . runIndexed
-  {-# INLINE rep #-}
 
+instance Cosieve (Indexed i) ((,) i) where
+  cosieve = uncurry . runIndexed
+  {-# INLINE cosieve #-}
+
+instance Corepresentable (Indexed i) where
+  type Corep (Indexed i) = (,) i
+  cotabulate = Indexed . curry
+  {-# INLINE cotabulate #-}
+
 instance Choice (Indexed i) where
   right' = right
   {-# INLINE right' #-}
@@ -316,3 +325,21 @@
 indexing64 :: Indexable Int64 p => ((a -> Indexing64 f b) -> s -> Indexing64 f t) -> p a (f b) -> s -> f t
 indexing64 l iafb s = snd $ runIndexing64 (l (\a -> Indexing64 (\i -> i `seq` (i + 1, indexed iafb i a))) s) 0
 {-# INLINE indexing64 #-}
+
+-------------------------------------------------------------------------------
+-- Converting to Folds
+-------------------------------------------------------------------------------
+
+-- | Fold a container with indices returning both the indices and the values.
+--
+-- The result is only valid to compose in a 'Traversal', if you don't edit the
+-- index as edits to the index have no effect.
+withIndex :: (Indexable i p, Functor f) => p (i, s) (f (j, t)) -> Indexed i s (f t)
+withIndex f = Indexed $ \i a -> snd <$> indexed f i (i, a)
+{-# INLINE withIndex #-}
+
+-- | When composed with an 'IndexedFold' or 'IndexedTraversal' this yields an
+-- ('Indexed') 'Fold' of the indices.
+asIndex :: (Indexable i p, Contravariant f, Functor f) => p i (f i) -> Indexed i s (f s)
+asIndex f = Indexed $ \i _ -> Getter.coerce (indexed f i i)
+{-# INLINE asIndex #-}
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
@@ -46,6 +46,7 @@
 import Data.Functor.Contravariant
 import Data.Monoid
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Data.Traversable
 import Prelude hiding ((.),id)
@@ -247,7 +248,7 @@
     go (MagmaAp x y)  = go x <*> go y
     go (MagmaFmap f x)  = f <$> go x
     go (MagmaPure x)    = pure x
-    go (Magma _ wa) = corep pafb wa
+    go (Magma _ wa) = cosieve pafb wa
   {-# INLINE bazaar #-}
 
 -- This constraint is unused intentionally, it protects TakingWhile
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
@@ -134,6 +134,7 @@
 import Data.Monoid
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Data.Void
 import Prelude
@@ -218,7 +219,7 @@
 -- | Build an index-preserving 'Lens' from a 'Control.Lens.Getter.Getter' and a
 -- 'Control.Lens.Setter.Setter'.
 iplens :: (s -> a) -> (s -> b -> t) -> IndexPreservingLens s t a b
-iplens sa sbt pafb = cotabulate $ \ws -> sbt (extract ws) <$> corep pafb (sa <$> ws)
+iplens sa sbt pafb = cotabulate $ \ws -> sbt (extract ws) <$> cosieve pafb (sa <$> ws)
 {-# INLINE iplens #-}
 
 -- | Build an 'IndexedLens' from a 'Control.Lens.Getter.Getter' and
@@ -383,8 +384,8 @@
 -- [2,1]
 inside :: Corepresentable p => ALens s t a b -> Lens (p e s) (p e t) (p e a) (p e b)
 inside l f es = o <$> f i where
-  i = cotabulate $ \ e -> ipos $ l sell (corep es e)
-  o ea = cotabulate $ \ e -> ipeek (corep ea e) $ l sell (corep es e)
+  i = cotabulate $ \ e -> ipos $ l sell (cosieve es e)
+  o ea = cotabulate $ \ e -> ipeek (cosieve ea e) $ l sell (cosieve es e)
 {-# INLINE inside #-}
 
 {-
@@ -441,7 +442,7 @@
 -- 'chosen' f ('Right' a) = 'Right' '<$>' f a
 -- @
 chosen :: IndexPreservingLens (Either a a) (Either b b) a b
-chosen pafb = cotabulate $ \weaa -> corep (either id id `lmap` pafb) weaa <&> \b -> case extract weaa of
+chosen pafb = cotabulate $ \weaa -> cosieve (either id id `lmap` pafb) weaa <&> \b -> case extract weaa of
   Left _  -> Left  b
   Right _ -> Right b
 {-# INLINE chosen #-}
@@ -506,7 +507,7 @@
 -- | Clone a 'Lens' as an 'IndexedPreservingLens' that just passes through whatever
 -- index is on any 'IndexedLens', 'IndexedFold', 'IndexedGetter' or  'IndexedTraversal' it is composed with.
 cloneIndexPreservingLens :: ALens s t a b -> IndexPreservingLens s t a b
-cloneIndexPreservingLens l pafb = cotabulate $ \ws -> runPretext (l sell (extract ws)) $ \a -> corep pafb (a <$ ws)
+cloneIndexPreservingLens l pafb = cotabulate $ \ws -> runPretext (l sell (extract ws)) $ \a -> cosieve pafb (a <$ ws)
 {-# INLINE cloneIndexPreservingLens #-}
 
 -- | Clone an 'IndexedLens' as an 'IndexedLens' with the same index.
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
@@ -58,6 +58,7 @@
 import Data.Functor.Identity
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Traversable
 import Data.Void
 #if MIN_VERSION_base(4,7,0)
@@ -140,7 +141,7 @@
 -- TODO: can we make this work with merely Strong?
 outside :: Representable p => APrism s t a b -> Lens (p t r) (p s r) (p b r) (p a r)
 outside k = withPrism k $ \bt seta f ft ->
-  f (lmap bt ft) <&> \fa -> tabulate $ either (rep ft) (rep fa) . seta
+  f (lmap bt ft) <&> \fa -> tabulate $ either (sieve ft) (sieve fa) . seta
 {-# INLINE outside #-}
 
 -- | Given a pair of prisms, project sums.
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
@@ -34,6 +34,7 @@
 import Data.Functor.Plus
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Semigroup
 
 -- $setup
@@ -167,15 +168,19 @@
   rmap f l    = Getter $ runGetter l.to f
   {-# INLINE rmap #-}
 
+instance Cosieve ReifiedGetter Identity where
+  cosieve (Getter l) = view l . runIdentity
+
 instance Corepresentable ReifiedGetter where
   type Corep ReifiedGetter = Identity
   cotabulate f = Getter $ to (f . Identity)
-  corep (Getter l) = view l . runIdentity
 
+instance Sieve ReifiedGetter Identity where
+  sieve (Getter l) = Identity . view l
+
 instance Representable ReifiedGetter where
   type Rep ReifiedGetter = Identity
   tabulate f = Getter $ to (runIdentity . f)
-  rep (Getter l) = Identity . view l
 
 instance Conjoined ReifiedGetter
 
@@ -239,12 +244,14 @@
   dimap f g l = IndexedGetter (to f . runIndexedGetter l . to g)
   {-# INLINE dimap #-}
 
+instance Sieve (ReifiedIndexedGetter i) ((,) i) where
+  sieve = iview . runIndexedGetter
+  {-# INLINE sieve #-}
+
 instance Representable (ReifiedIndexedGetter i) where
   type Rep (ReifiedIndexedGetter i) = (,) i
   tabulate f = IndexedGetter $ ito f
   {-# INLINE tabulate #-}
-  rep = iview . runIndexedGetter
-  {-# INLINE rep #-}
 
 instance Strong (ReifiedIndexedGetter i) where
   first' l = IndexedGetter $ \f (s,c) ->
@@ -287,10 +294,12 @@
   lmap f l = Fold (to f . runFold l)
   {-# INLINE lmap #-}
 
+instance Sieve ReifiedFold [] where
+  sieve = toListOf . runFold
+
 instance Representable ReifiedFold where
   type Rep ReifiedFold = []
   tabulate f = Fold (folding f)
-  rep = toListOf . runFold
 
 instance Strong ReifiedFold where
   first' l = Fold $ \f (s,c) ->
@@ -442,12 +451,14 @@
   rmap g l = IndexedFold (runIndexedFold l . to g)
   {-# INLINE rmap #-}
 
+instance Sieve (ReifiedIndexedFold i) (Compose [] ((,) i)) where
+  sieve (IndexedFold l) = Compose . itoListOf l
+  {-# INLINE sieve #-}
+
 instance Representable (ReifiedIndexedFold i) where
   type Rep (ReifiedIndexedFold i) = Compose [] ((,) i)
   tabulate k = IndexedFold $ \f -> coerce . traverse_ (coerce . uncurry (indexed f)) . getCompose . k
   {-# INLINE tabulate #-}
-  rep (IndexedFold l) = Compose . itoListOf l
-  {-# INLINE rep #-}
 
 instance Strong (ReifiedIndexedFold i) where
   first' l  = IndexedFold $ \f (s,c) ->
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
@@ -86,6 +86,7 @@
 import Data.Monoid
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Prelude
 
@@ -275,7 +276,7 @@
 -- 'setting' :: ((a -> b) -> s -> t) -> 'Setter' s t a b
 -- @
 setting :: ((a -> b) -> s -> t) -> IndexPreservingSetter s t a b
-setting l pafb = cotabulate $ \ws -> pure $ l (\a -> untainted (corep pafb (a <$ ws))) (extract ws)
+setting l pafb = cotabulate $ \ws -> pure $ l (\a -> untainted (cosieve pafb (a <$ ws))) (extract ws)
 {-# INLINE setting #-}
 
 -- | Build a 'Setter', 'IndexedSetter' or 'IndexPreservingSetter' depending on your choice of 'Profunctor'.
@@ -295,7 +296,7 @@
 -- | Build an 'IndexPreservingSetter' from any 'Setter'.
 cloneIndexPreservingSetter :: ASetter s t a b -> IndexPreservingSetter s t a b
 cloneIndexPreservingSetter l pafb = cotabulate $ \ws ->
-    taintedDot runIdentity $ l (\a -> Identity (untainted (corep pafb (a <$ ws)))) (extract ws)
+    taintedDot runIdentity $ l (\a -> Identity (untainted (cosieve pafb (a <$ ws)))) (extract ws)
 {-# INLINE cloneIndexPreservingSetter #-}
 
 -- | Clone an 'IndexedSetter'.
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
@@ -116,14 +116,26 @@
   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.
+-- allow fields of an undefined value to be initialized with lenses:
 --
+-- @
+-- data Foo = Foo {_x :: Int, _y :: Bool}
+--   deriving Show
+--
+-- 'makeLensesWith' ('lensRules' & 'generateLazyPatterns' .~ True) ''Foo
+-- @
+--
+-- @
+-- > undefined & x .~ 8 & y .~ True
+-- Foo {_x = 8, _y = True}
+-- @
+-- 
 -- The downside of this flag is that it can lead to space-leaks and
--- code-size/compile-time increases when generated for large records.
+-- code-size/compile-time increases when generated for large records. By
+-- default this flag is turned off, and strict optics are generated.
 --
 -- When using lazy optics the strict optic can be recovered by composing
--- with '$!'
+-- with '$!':
 --
 -- @
 -- strictOptic = ($!) . lazyOptic
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
@@ -145,6 +145,7 @@
 import Data.Monoid
 import Data.Profunctor
 import Data.Profunctor.Rep
+import Data.Profunctor.Sieve
 import Data.Profunctor.Unsafe
 import Data.Semigroup.Traversable
 import Data.Tagged
@@ -434,7 +435,7 @@
 --
 mapAccumLOf :: Conjoined p => Over p (State acc) s t a b -> p acc (a -> (acc, b)) -> acc -> s -> (acc, t)
 mapAccumLOf l f acc0 s = swap (runState (l g s) acc0) where
-   g = cotabulate $ \wa -> state $ \acc -> swap (corep f (acc <$ wa) (extract wa))
+   g = cotabulate $ \wa -> state $ \acc -> swap (cosieve f (acc <$ wa) (extract wa))
 -- This would be much cleaner if the argument order for the function was swapped.
 {-# INLINE mapAccumLOf #-}
 
@@ -602,7 +603,7 @@
       in f (ins b) (unsafeOuts b))
      (Tagged $ let
         f [] _ = []
-        f (wx:xs) g = Pretext (\wxfy -> g . (:Prelude.map extract xs) <$> corep wxfy wx) : f xs (g . (extract wx:))
+        f (wx:xs) g = Pretext (\wxfy -> g . (:Prelude.map extract xs) <$> cosieve wxfy wx) : f xs (g . (extract wx:))
       in f (pins b) (unsafeOuts b))
     :: Tagged (p a b) [Pretext p a a t]
   ) where b = l sell s
@@ -643,8 +644,8 @@
     (w:ws) -> unsafeOuts b . (:ws) <$> afb w
     []     -> unsafeOuts b . return <$> afb (error "singular: empty traversal"))
   (\pafb s -> let b = l sell s in case pins b of
-    (w:ws) -> unsafeOuts b . (:Prelude.map extract ws) <$> corep pafb w
-    []     -> unsafeOuts b . return                    <$> corep pafb (error "singular: empty traversal"))
+    (w:ws) -> unsafeOuts b . (:Prelude.map extract ws) <$> cosieve pafb w
+    []     -> unsafeOuts b . return                    <$> cosieve pafb (error "singular: empty traversal"))
 {-# INLINE singular #-}
 
 -- | This converts a 'Traversal' that you \"know\" will target only one element to a 'Lens'. It can also be
@@ -671,7 +672,7 @@
     []  -> error "unsafeSingular: empty traversal"
     _   -> error "unsafeSingular: traversing multiple results")
   (\pafb s -> let b = inline l sell s in case pins b of
-    [w] -> unsafeOuts b . return <$> corep pafb w
+    [w] -> unsafeOuts b . return <$> cosieve pafb w
     []  -> error "unsafeSingular: empty traversal"
     _   -> error "unsafeSingular: traversing multiple results")
 {-# INLINE unsafeSingular #-}
@@ -770,7 +771,7 @@
        => Optical p q f s t a b
        -> Optical p q f s' t' a b
        -> Optical p q f (r s s') (r t t') a b
-beside l r f = tabulate $ getCompose #. bitraverse (Compose #. rep (l f)) (Compose #. rep (r f))
+beside l r f = tabulate $ getCompose #. bitraverse (Compose #. sieve (l f)) (Compose #. sieve (r f))
 {-# INLINE beside #-}
 
 -- | Visit the first /n/ targets of a 'Traversal', 'Fold', 'Getter' or 'Lens'.
@@ -802,7 +803,7 @@
        -> Over p f s t a a
 taking n l = conjoined
   (\ afb s  -> let b = inline l sell s in outs b <$> traverse afb          (take n $ ins b))
-  (\ pafb s -> let b = inline l sell s in outs b <$> traverse (corep pafb) (take n $ pins b))
+  (\ pafb s -> let b = inline l sell s in outs b <$> traverse (cosieve pafb) (take n $ pins b))
 {-# INLINE taking #-}
 
 -- | Visit all but the first /n/ targets of a 'Traversal', 'Fold', 'Getter' or 'Lens'.
@@ -829,7 +830,7 @@
 -- @
 dropping :: (Conjoined p, Applicative f) => Int -> Over p (Indexing f) s t a a -> Over p f s t a a
 dropping n l pafb s = snd $ runIndexing (l paifb s) 0 where
-  paifb = cotabulate $ \wa -> Indexing $ \i -> let i' = i + 1 in i' `seq` (i', if i < n then pure (extract wa) else corep pafb wa)
+  paifb = cotabulate $ \wa -> Indexing $ \i -> let i' = i + 1 in i' `seq` (i', if i < n then pure (extract wa) else cosieve pafb wa)
 {-# INLINE dropping #-}
 
 ------------------------------------------------------------------------------
@@ -846,7 +847,7 @@
 -- as such, use 'Control.Lens.Lens.cloneLens'.
 --
 -- Note: It is usually better to use 'Control.Lens.Reified.ReifiedTraversal' and
--- 'Control.Lens.Reified.reflectTraversal' than to 'cloneTraversal'. The
+-- 'Control.Lens.Reified.runTraversal' than to 'cloneTraversal'. The
 -- former can execute at full speed, while the latter needs to round trip through
 -- the 'Bazaar'.
 --
@@ -864,7 +865,7 @@
 -- | Clone a 'Traversal' yielding an 'IndexPreservingTraversal' that passes through
 -- whatever index it is composed with.
 cloneIndexPreservingTraversal :: ATraversal s t a b -> IndexPreservingTraversal s t a b
-cloneIndexPreservingTraversal l pafb = cotabulate $ \ws -> runBazaar (l sell (extract ws)) $ \a -> corep pafb (a <$ ws)
+cloneIndexPreservingTraversal l pafb = cotabulate $ \ws -> runBazaar (l sell (extract ws)) $ \a -> cosieve pafb (a <$ ws)
 {-# INLINE cloneIndexPreservingTraversal #-}
 
 -- | Clone an 'IndexedTraversal' yielding an 'IndexedTraversal' with the same index.
@@ -880,7 +881,7 @@
 -- | Clone a 'Traversal1' yielding an 'IndexPreservingTraversal1' that passes through
 -- whatever index it is composed with.
 cloneIndexPreservingTraversal1 :: ATraversal1 s t a b -> IndexPreservingTraversal1 s t a b
-cloneIndexPreservingTraversal1 l pafb = cotabulate $ \ws -> runBazaar1 (l sell (extract ws)) $ \a -> corep pafb (a <$ ws)
+cloneIndexPreservingTraversal1 l pafb = cotabulate $ \ws -> runBazaar1 (l sell (extract ws)) $ \a -> cosieve pafb (a <$ ws)
 {-# INLINE cloneIndexPreservingTraversal1 #-}
 
 -- | Clone an 'IndexedTraversal1' yielding an 'IndexedTraversal1' with the same index.
@@ -1201,11 +1202,12 @@
 -- 'failing' :: 'IndexedLens' i s t a b      -> 'IndexedTraversal' i s t a b -> 'IndexedTraversal' i s t a b
 -- 'failing' :: 'IndexedGetter' i s a        -> 'IndexedGetter' i s a        -> 'IndexedFold' i s a
 -- @
-failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Traversing p f s t a b -> Over p f s t a b
+failing :: (Conjoined p, Applicative f) => Traversing p f s t a b -> Over p f s t a b -> Over p f s t a b
 failing l r pafb s = case pins b of
-  [] -> runBazaarT (r sell s) pafb
-  xs -> unsafeOuts b <$> traverse (corep pafb) xs
+  [] -> r pafb s
+  _  -> bazaar pafb b
   where b = l sell s
+
 infixl 5 `failing`
 
 -- | Try the second traversal. If it returns no entries, try again with all entries from the first traversal, recursively.
@@ -1221,7 +1223,7 @@
 deepOf r l pafb = go
   where go s = case pins b of
           [] -> r go s
-          xs -> unsafeOuts b <$> traverse (corep pafb) xs
+          xs -> unsafeOuts b <$> traverse (cosieve pafb) xs
           where b = l sell s
 
 -- | "Fuse" a 'Traversal' by reassociating all of the '\<*\>' operations to the