lens 4.9.1 → 4.10

raw patch · 17 files changed

+189/−98 lines, 17 filesdep ~bifunctorsdep ~profunctorsdep ~semigroupoidsPVP ok

version bump matches the API change (PVP)

Dependency ranges changed: bifunctors, profunctors, semigroupoids

API changes (from Hackage documentation)

Files

• .travis.yml +1/−1
• CHANGELOG.markdown +6/−0
• README.markdown +0/−7
• lens.cabal +5/−12
• src/Control/Lens/At.hs +3/−5
• src/Control/Lens/Fold.hs +65/−4
• src/Control/Lens/Indexed.hs +0/−18
• src/Control/Lens/Internal/Bazaar.hs +5/−4
• src/Control/Lens/Internal/Context.hs +4/−3
• src/Control/Lens/Internal/Indexed.hs +36/−9
• src/Control/Lens/Internal/Magma.hs +2/−1
• src/Control/Lens/Lens.hs +6/−5
• src/Control/Lens/Prism.hs +2/−1
• src/Control/Lens/Reified.hs +18/−7
• src/Control/Lens/Setter.hs +3/−2
• src/Control/Lens/TH.hs +16/−4
• src/Control/Lens/Traversal.hs +17/−15

@@ -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

@@ -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`.

@@ -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>

@@ -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

@@ -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

@@ -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

@@ -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 ------------------------------------------------------------------------------- 

@@ -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

@@ -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 #-}

@@ -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 #-}

@@ -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

@@ -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.

@@ -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.

@@ -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) ->

@@ -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'.

@@ -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

@@ -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