!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ TemplateHaskell experimentalEdward Kmett <ekmett@gmail.com> Trustworthy*Derive lenses for the record selectors in ( a single-constructor data declaration, 6 or for the record selector in a newtype declaration. 7 Lenses will only be generated for record fields which " are prefixed with an underscore. Example usage:  makeLenses ''Foo /Derive lenses, specifying explicit pairings of (fieldName, lensName). Example usage: < makeLensesFor [("_foo", "fooLens"), ("bar", "lbar")] ''Foo 4Derive lenses with the provided name transformation ! and filtering function. Produce  Just lensName to generate a lens  of the resultant name, or Nothing to not generate a lens  for the input record name. Example usage: , makeLensesBy (\n -> Just (n ++ "L")) ''Foo the name transformer  Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered Run an Applicative backwards  Used for  maximumOf  Used for  minimumOf Used internally by  and the like. Used internally by  traverseOf_,  and the like. Applicative composition of  State Int with a , used  by  elementOf,  elementsOf, traverseElement, traverseElementsOf 0The indexed store can be used to characterize a  LensFamily  and is used by clone Used by Focus Obtain the minimum Obtain the maximum $          Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Inferedu!A !I describes how to retrieve multiple values in a way that can be composed % with other lens-like constructions. A ! a b c dC provides a structure with operations very similar to those of the   typeclass, see j and the other ! combinators. !By convention, if there exists a foo method that expects a  (f c), then there should be a  fooOf method that takes a ! a b c d and a value of type a. A # is a legal ! that just ignores the supplied   Unlike a / a ! is read-only. Since a ! cannot be used to write back 3 there are no lens laws that can be applied to it. In practice the b and dA are left dangling and unused, and as such is no real point in a . !. = type Fold a b c d = forall m. Monoid m => Getting m a b c d "Most #- combinators are able to be used with both a # or a ! in S limited situations, to do so, they need to be monomorphic in what we are going to  extract with . If a function accepts a Getting r a b c d , then when r is a Monoid, you can  pass a ! (or /&), otherwise you can only pass this a # or 0. 5 type Getting r a b c d = LensLike (Const r) a b c d #A #M describes how to retrieve a single value in a way that can be composed with  other lens-like constructions.  Unlike a 0 a # is read-only. Since a # cannot be used to write back 3 there are no lens laws that can be applied to it.  Moreover, a # can be used directly as a !, since it just ignores the . In practice the b and d? are left dangling and unused, and as such is no real point in  using a . #. ;type Getter a b c d = forall z. LensLike (Const z) a b c d $(This alias is supplied for those who don't want to bother using {- LANGUAGE LiberalTypeSynonyms -} and .. % 'SimpleSetter ' = 'Simple' 'Setter' % The only 0-like law that can apply to a % l is that  ! set l c (set l b a) = set l c a You can't N a %3 in general, so the other two laws are irrelevant. You can compose a % with a 0 or a / using (.) from the Prelude ! and the result is always only a % and nothing more. 1 type Setter a b c d = LensLike Identity a b c d &This class allows us to use '. on a number of different monad transformers. 'IRun a monadic action in a larger context than it was defined in, using a . 0 or . /. lThis 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 /M over multiple values, the actions for each target are executed sequentially + and the results are aggregated monoidally  and a monoidal summary  of the result is given. N focus :: Monad m => Simple Lens a b -> st b m c -> st a m c N focus :: (Monad m, Monoid c) => Simple Traversal a b -> st b m c -> st a m c (Like '4, but discarding any accumulated results as you go. P focus_ :: Monad m => Simple Lens a b -> st b m c -> st a m () P focus_ :: (Monad m, Monoid c) => Simple Traversal a b -> st b m c -> st a m () )A much more limited version of ' that can work with a %. *Many combinators that accept a 0 can also accept a / in limited situations. 'They do so by specializing the type of " that they require of the caller. If a function accepts a * f a b c d for some  f, then they may be passed a 0.  Further, if f is an , they may also be passed a /. + - type SimpleLensLike f = Simple (LensLike f) ,  type SimpleLens = Simple Lens - ) type SimpleTraversal = Simple Traversal .A . 0, . /, ... can be used instead of a 0,/, ...  whenever the type variables don't change upon setting a value.  ( imaginary :: Simple Lens (Complex a) a ( traverseHead :: Simple Traversal [a] a .Note: To use this alias in your own code with * f or Setter, you may have to turn on  LiberalTypeSynonyms. /A / can be used directly as a % or a ! (but not as a 0) and provides V the ability to both read and update multiple fields, subject to some relatively weak / laws. UThese have also been known as multilenses, but they have the signature and spirit of  8 traverse :: Traversable f => Traversal (f a) (f b) a b 8and the more evocative name suggests their application. Most of the time the / you will want to use is just , but you can also pass any  0) -- as a Traversal, and composition of a / (or 0 ) with a / (or 0)  using (.) forms a /. 0A 0+ is actually a lens family as described in  /http://comonad.com/reader/2012/mirrored-lenses/. 2With great power comes great responsibility and a 01 is subject to the three common sense lens laws: !1) You get back what you put in:   view l (set l b a) = b "2) Putting back what you got doesn't change anything:   set l (view l a) a = a .3) Setting twice is the same as setting once:  ! set l c (set l b a) = set l c a =These laws are strong enough that the 4 type parameters of a 0. cannot vary fully independently. For more on  how they interact, read the Why is it a Lens Family? section of  /http://comonad.com/reader/2012/mirrored-lenses/. Every 0 can be used directly as a #, %, ! or /.  0 identity :: Lens (Identity a) (Identity b) a b , identity f (Identity a) = Identity <$> f a 7 type Lens = forall f. Functor f => LensLike f a b c d 1Build a 0 from a getter and a setter. J lens :: Functor f => (a -> c) -> (a -> d -> b) -> (c -> f d) -> a -> f b 2Built a 0 from an isomorphism family D iso :: Functor f => (a -> c) -> (d -> b) -> (c -> f d) -> a -> f b 3(3') can be used in one of two scenarios: When applied to a 0 , it can edit the target of the 0 in a structure, extracting a - supplemental result, and the new structure. When applied to a /!, it can edit the targets of the  Traversals, extracting a / supplemental monoidal summary of its actions. 8For all that the definition of this combinator is just:   (%%~) = id [It may be beneficial to think about it as if it had these more restrictive types, however: H (%%~) :: Lens a b c d -> (c -> (e, d)) -> a -> (e, b) H (%%~) :: Monoid m => Traversal a b c d -> (c -> (m, d)) -> a -> (m, b) 4Modify the target of a 0: in the current state returning some extra information of c or  modify all targets of a /< in the current state, extracting extra information of type c / and return a monoidal summary of the changes.   (%%=) = (state.) It may be useful to think of (4>), instead, as having either of the following more restricted  type signatures: Q (%%=) :: MonadState a m => Lens a a c d -> (c -> (e, d) -> m e Q (%%=) :: (MonadState a m, Monoid e) => Traversal a a c d -> (c -> (e, d) -> m e 5AMap each element of a structure targeted by a Lens or Traversal, E evaluate these actions from left to right, and collect the results.   traverseOf = id   traverse = traverseOf traverse ; traverseOf :: Lens a b c d -> (c -> f d) -> a -> f b ; traverseOf :: Traversal a b c d -> (c -> f d) -> a -> f b 6  forOf = flip  forOf l = flip (traverseOf l)  for = forOf traverse 7FEvaluate each action in the structure from left to right, and collect  the results.  " sequenceA = sequenceAOf traverse ! sequenceAOf l = traverseOf l id  sequenceAOf l = l id > sequenceAOf :: Lens a b (f c) c -> a -> f b C sequenceAOf :: Applicative f => Traversal a b (f c) c -> a -> f b 8HMap each element of a structure targeted by a lens to a monadic action, E evaluate these actions from left to right, and collect the results.   mapM = mapMOf traverse B mapMOf :: Lens a b c d -> (c -> m d) -> a -> m b B mapMOf :: Monad m => Traversal a b c d -> (c -> m d) -> a -> m b 9  forM = forMOf traverse  forMOf l = flip (mapMOf l) = forMOf :: Lens a b c d -> a -> (c -> m d) -> m b = forMOf :: Monad m => Lens a b c d -> a -> (c -> m d) -> m b :  sequence = sequenceOf traverse  sequenceOf l = mapMOf l id * sequenceOf l = unwrapMonad . l WrapMonad < sequenceOf :: Lens a b (m c) c -> a -> m b < sequenceOf :: Monad m => Traversal a b (m c) c -> a -> m b ;This generalizes  to an arbitrary /.  " transpose = transposeOf traverse  . ghci> transposeOf traverse [[1,2,3],[4,5,6]]  [[1,4],[2,5],[3,6]]  Since every 0. is a Traversal, we can use this as a form of  monadic strength. ( transposeOf _2 :: (b, [a]) -> [(b, a)] < Generalizes  to an arbitrary /.  " mapAccumR = mapAccumROf traverse <' accumulates state from right to left. L mapAccumROf :: Lens a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) L mapAccumROf :: Traversal a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) = Generalized  to an arbitrary /.  " mapAccumL = mapAccumLOf traverse =' accumulates state from left to right. L mapAccumLOf :: Lens a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) L mapAccumLOf :: Traversal a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) >Permit the use of  over an arbitrary / or 0.   scanr1 = scanr1Of traverse : scanr1Of :: Lens a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Traversal a b c c -> (c -> c -> c) -> a -> b ?Permit the use of  over an arbitrary / or 0.   scanl1 = scanl1Of traverse : scanr1Of :: Lens a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Traversal a b c c -> (c -> c -> c) -> a -> b @;This setter can be used to map over all of the values in a .  fmap = adjust mapped  fmapDefault = adjust traverse  (<$) = set mapped ABuild a Setter.  sets . adjust = id  adjust . sets = id BModify the target of a 0 or all the targets of a % or /  with a function.   fmap = adjust mapped  fmapDefault = adjust traverse  sets . adjust = id  adjust . sets = id CReplace the target of a 0 or all of the targets of a %  or / with a constant value.  (<$) = set mapped DModifies the target of a 0 or all of the targets of a % or  / with a user supplied function. This is an infix version of B   fmap f = mapped %~ f  fmapDefault f = traverse %~ f " ghci> _2 %~ length $ (1,"hello")  (1,5) EReplace the target of a 0 or all of the targets of a %  or / with a constant value. This is an infix version of C   f <$ a = mapped ^~ f $ a  ghci> bitAt 0 ^~ True $ 0  1 F0Increment the target(s) of a numerically valued 0, Setter' or /  ghci> _1 +~ 1 $ (1,2)  (2,2) G/Multiply the target(s) of a numerically valued 0, % or /  ghci> _2 *~ 4 $ (1,2)  (1,8) H0Decrement the target(s) of a numerically valued 0, % or /  ghci> _1 -~ 2 $ (1,2)  (-1,2) I-Divide the target(s) of a numerically valued 0, % or / J Logically  the target(s) of a -valued 0 or % K Logically  the target(s) of a -valued 0 or % L,Modify the target of a monoidally valued by ing another value. MBuild a #% from an arbitrary Haskell function.  to f . to g = to (g . f) NView the value pointed to by a # or 0 or the result of folding over  all the results of a ! or /# that points at a monoidal values. It may be useful to think of N. as having these more restrictive signatures:  1 view :: Lens a b c d -> a -> c 1 view :: Getter a b c d -> a -> c 1 view :: Monoid m => Fold a b m d -> a -> m 1 view :: Monoid m => Traversal a b m d -> a -> m 8 view :: ((c -> Const c d) -> a -> Const c b) -> a -> c OView the value of a #, 0# or the result of folding over the $ result of mapping the targets of a ! or /. It may be useful to think of O. as having these more restrictive signatures:  > views :: Getter a b c d -> (c -> d) -> a -> d > views :: Lens a b c d -> (c -> d) -> a -> d > views :: Monoid m => Fold a b c d -> (c -> m) -> a -> m > views :: Monoid m => Traversal a b c d -> (c -> m) -> a -> m E views :: ((c -> Const m d) -> a -> Const m b) -> (c -> m) -> a -> m PView the value pointed to by a # or 0 or the result of folding over  all the results of a ! or /# that points at a monoidal values. This is the same operation as N, only infix.  1 (^$) :: Lens a b c d -> a -> c 1 (^$) :: Getter a b c d -> a -> c 1 (^$) :: Monoid m => Fold a b m d -> a -> m 1 (^$) :: Monoid m => Traversal a b m d -> a -> m 8 (^$) :: ((c -> Const c d) -> a -> Const c b) -> a -> c QView the value pointed to by a # or 0 or the result of folding over  all the results of a ! or /# that points at a monoidal values. This is the same operation as N with the arguments flipped. HThe fixity and semantics are such that subsequent field accesses can be  performed with (Prelude..)  , ghci> ((0, 1 :+ 2), 3)^._1._2.to magnitude  2.23606797749979  1 (^.) :: a -> Lens a b c d -> c 1 (^.) :: a -> Getter a b c d -> c 1 (^.) :: Monoid m => a -> Fold a b m d -> m 1 (^.) :: Monoid m => a -> Traversal a b m d -> m 8 (^.) :: a -> ((c -> Const c d) -> a -> Const c b) -> c RJThis is a lens that can change the value (and type) of the first field of  a pair.   ghci> (1,2)^._1  1   ghci> _1 +~ "hello" $ (1,2)  ("hello",2) 3 _1 :: Functor f => (a -> f b) -> (a,c) -> f (a,c) SAs R&, but for the second field of a pair.  + anyOf _2 :: (c -> Bool) -> (a, c) -> Bool Y traverse._2 :: (Applicative f, Traversable t) => (a -> f b) -> t (c, a) -> f (t (c, b)) S foldMapOf (traverse._2) :: (Traversable t, Monoid m) => (c -> m) -> t (b, c) -> m 3 _2 :: Functor f => (a -> f b) -> (c,a) -> f (c,b) TCThis lens can be used to access the contents of the Identity monad UHThis lens can be used to change the result of a function but only where $ the arguments match the key given. VTell a part of a value to a , filling in the rest from  % whisper l d = tell (set l d mempty) WQuery the target of a 0 or # in the current state, or use a  summary of a ! or /" that points to a monoidal value.  B query :: MonadReader a m => Getter a b c d -> m c B query :: MonadReader a m => Lens a b c d -> m c B query :: (MonadReader a m, Monoid c) => Fold a b c d -> m c B query :: (MonadReader a m, Monoid c) => Traversal a b c d -> m c I query :: MonadReader a m => ((c -> Const c d) -> a -> Const c b) -> m c XUse the target of a 0 or # in the current state, or use a  summary of a ! or /" that points to a monoidal value.  P queries :: MonadReader a m => Getter a b c d -> (c -> e) -> m e P queries :: MonadReader a m => Lens a b c d -> (c -> e) -> m e P queries :: (MonadReader a m, Monoid c) => Fold a b c d -> (c -> e) -> m e P queries :: (MonadReader a m, Monoid c) => Traversal a b c d -> (c -> e) -> m e W queries :: MonadReader a m => ((c -> Const e d) -> a -> Const e b) -> (c -> e) -> m e YUse the target of a 0 or # in the current state, or use a  summary of a ! or /" that points to a monoidal value.  ? use :: MonadState a m => Getter a b c d -> m c ? use :: MonadState a m => Lens a b c d -> m c ? use :: (MonadState a m, Monoid c) => Fold a b c d -> m c ? use :: (MonadState a m, Monoid c) => Traversal a b c d -> m c F use :: MonadState a m => ((c -> Const c d) -> a -> Const c b) -> m c ZUse the target of a 0 or # in the current state, or use a  summary of a ! or /" that points to a monoidal value.  L uses :: MonadState a m => Getter a b c d -> (c -> e) -> m e L uses :: MonadState a m => Lens a b c d -> (c -> e) -> m e L uses :: (MonadState a m, Monoid c) => Fold a b c d -> (c -> e) -> m e L uses :: (MonadState a m, Monoid c) => Traversal a b c d -> (c -> e) -> m e S uses :: MonadState a m => ((c -> Const e d) -> a -> Const e b) -> (c -> e) -> m e [Replace the target of a 0 or all of the targets of a % or / in our monadic 2 state with a new value, irrespective of the old. \Map over the target of a 0 or all of the targets of a % or ' Traversal in our monadic state. ]Modify the target(s) of a . 0, % or / by adding a value  Example:  fresh = do  id += 1  access id ^Modify the target(s) of a . 0, % or / by subtracting a value _Modify the target(s) of a . 0, % or / by multiplying by value `Modify the target(s) of a . 0, % or / by dividing by a value aModify the target(s) of a . 0, % or / by taking their logical  with a value bModify the target(s) of a . 0, % or / by taking their logical  with a value cModify the target(s) of a . 0, % or / by  ing a value. d Obtain a !9 by lifting an operation that returns a foldable result. +This can be useful to lift operations from  Data.List and elsewhere into a !. e Obtain a ! from any   folded = folding id f Obtain a ! by filtering a 0, 'Getter, ! or /. g Obtain a !+ by reversing the order of traversal for a 0, #, ! or /. Of course, reversing a ! or # has no effect. h Obtain a !! by taking elements from another !, 0, # or / while a predicate holds.  / takeWhile p = toListOf (takingWhile p folded) / ghci> toList (takingWhile (<=3) folded) [1..]  [1,2,3] i Obtain a !# by dropping elements from another !, 0, # or / while a predicate holds.  1 dropWhile p = toListOf (droppingWhile p folded) . ghci> toList (dropWhile (<=3) folded) [1..6]  [4,5,6] j  foldMap = foldMapOf folded   foldMapOf = views B foldMapOf :: Getter a b c d -> (c -> m) -> a -> m B foldMapOf :: Lens a b c d -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Fold a b c d -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Traversal a b c d -> (c -> m) -> a -> m k  fold = foldOf folded   foldOf = view 3 foldOf :: Getter a b m d -> a -> m 3 foldOf :: Lens a b m d -> a -> m 3 foldOf :: Monoid m => Fold a b m d -> a -> m 3 foldOf :: Monoid m => Traversal a b m d -> a -> m lIRight-associative fold of parts of a structure that are viewed through a 0, #, ! or /.   foldr = foldrOf folded > foldrOf :: Getter a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Lens a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Fold a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Traversal a b c d -> (c -> e -> e) -> e -> a -> e mLLeft-associative fold of the parts of a structure that are viewed through a 0, #, ! or /.   foldl = foldlOf folded > foldlOf :: Getter a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Lens a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Fold a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Traversal a b c d -> (e -> c -> e) -> e -> a -> e n  toList = toListOf folded + toListOf :: Getter a b c d -> a -> [c] + toListOf :: Lens a b c d -> a -> [c] + toListOf :: Fold a b c d -> a -> [c] + toListOf :: Traversal a b c d -> a -> [c] o  and = andOf folded + andOf :: Getter a b Bool d -> a -> Bool + andOf :: Lens a b Bool d -> a -> Bool + andOf :: Fold a b Bool d -> a -> Bool + andOf :: Traversl a b Bool d -> a -> Bool p  or = orOf folded + orOf :: Getter a b Bool d -> a -> Bool + orOf :: Lens a b Bool d -> a -> Bool + orOf :: Fold a b Bool d -> a -> Bool + orOf :: Traversal a b Bool d -> a -> Bool q  any = anyOf folded 8 anyOf :: Getter a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Fold a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool r  all = allOf folded 8 allOf :: Getter a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Fold a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool s  product = productOf folded 3 productOf :: Getter a b c d -> a -> c 3 productOf :: Lens a b c d -> a -> c 3 productOf :: Num c => Fold a b c d -> a -> c 3 productOf :: Num c => Traversal a b c d -> a -> c t  sum = sumOf folded   sumOf _1 :: (a, b) -> a ; sumOf (folded._1) :: (Foldable f, Num a) => f (a, b) -> a / sumOf :: Getter a b c d -> a -> c / sumOf :: Lens a b c d -> a -> c / sumOf :: Num c => Fold a b c d -> a -> c / sumOf :: Num c => Traversal a b c d -> a -> c uWhen passed a #, u can work over a . When passed a !, u requires an .   traverse_ = traverseOf_ folded  > traverseOf_ _2 :: Functor f => (c -> f e) -> (c1, c) -> f () O traverseOf_ traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f () bThe rather specific signature of traverseOf_ allows it to be used as if the signature was either: N traverseOf_ :: Functor f => Getter a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Lens a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Fold a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Traversal a b c d -> (c -> f e) -> a -> f () v  for_ = forOf_ folded I forOf_ :: Functor f => Getter a b c d -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Lens a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Fold a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Traversal a b c d -> a -> (c -> f e) -> f () w " sequenceA_ = sequenceAOf_ folded F sequenceAOf_ :: Functor f => Getter a b (f ()) d -> a -> f () F sequenceAOf_ :: Functor f => Lens a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Fold a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Traversal a b (f ()) d -> a -> f () x  mapM_ = mapMOf_ folded D mapMOf_ :: Monad m => Getter a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Lens a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Fold a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Traversal a b c d -> (c -> m e) -> a -> m () y  forM_ = forMOf_ folded D forMOf_ :: Monad m => Getter a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Lens a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Fold a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Traversal a b c d -> a -> (c -> m e) -> m () z  sequence_ = sequenceOf_ folded > sequenceOf_ :: Monad m => Getter a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Lens a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Fold a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Traversal a b (m b) d -> a -> m () {1The sum of a collection of actions, generalizing .   asum = asumOf folded : asumOf :: Alternative f => Getter a b c d -> a -> f c : asumOf :: Alternative f => Lens a b c d -> a -> f c : asumOf :: Alternative f => Fold a b c d -> a -> f c : asumOf :: Alternative f => Traversal a b c d -> a -> f c |1The sum of a collection of actions, generalizing .   msum = msumOf folded 8 msumOf :: MonadPlus m => Getter a b c d -> a -> m c 8 msumOf :: MonadPlus m => Lens a b c d -> a -> m c 8 msumOf :: MonadPlus m => Fold a b c d -> a -> m c 8 msumOf :: MonadPlus m => Traversal a b c d -> a -> m c }  elem = elemOf folded 7 elemOf :: Eq c => Getter a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Lens a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Fold a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Traversal a b c d -> c -> a -> Bool ~  notElem = notElemOf folded : notElemOf :: Eq c => Getter a b c d -> c -> a -> Bool : notElemOf :: Eq c => Fold a b c d -> c -> a -> Bool : notElemOf :: Eq c => Lens a b c d -> c -> a -> Bool : notElemOf :: Eq c => Traversal a b c d -> c -> a -> Bool   concatMap = concatMapOf folded < concatMapOf :: Getter a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Lens a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Fold a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Traversal a b c d -> (c -> [e]) -> a -> [e]   concat = concatOf folded * concatOf :: Getter a b [e] d -> a -> [e] ( concatOf :: Lens a b [e] d -> a -> [e] ( concatOf :: Fold a b [e] d -> a -> [e] # concatOf :: a b [e] d -> a -> [e] ;Note: this can be rather inefficient for large containers.   length = lengthOf folded   lengthOf _1 :: (a, b) -> Int  lengthOf _1 = 1 : lengthOf (folded.folded) :: Foldable f => f (g a) -> Int + lengthOf :: Getter a b c d -> a -> Int + lengthOf :: Lens a b c d -> a -> Int + lengthOf :: Fold a b c d -> a -> Int + lengthOf :: Traversal a b c d -> a -> Int Perform a safe  of a ! or / or retrieve  the result  from a # or 0.  & listToMaybe . toList = headOf folded - headOf :: Getter a b c d -> a -> Maybe c - headOf :: Lens a b c d -> a -> Maybe c - headOf :: Fold a b c d -> a -> Maybe c - headOf :: Traversal a b c d -> a -> Maybe c Perform a safe  of a ! or / or retrieve  the result  from a # or 0. - lastOf :: Getter a b c d -> a -> Maybe c - lastOf :: Lens a b c d -> a -> Maybe c - lastOf :: Fold a b c d -> a -> Maybe c - lastOf :: Traversal a b c d -> a -> Maybe c Returns  if this ! or /( has no targets in the given container. Note: nullOf on a valid 0 or # should always return    null = nullOf folded /This may be rather inefficient compared to the  check of many containers.   nullOf _1 :: (a, b) -> Int  nullOf _1 = False ? nullOf (folded._1.folded) :: Foldable f => f (g a, b) -> Bool * nullOf :: Getter a b c d -> a -> Bool * nullOf :: Lens a b c d -> a -> Bool * nullOf :: Fold a b c d -> a -> Bool * nullOf :: Traversal a b c d -> a -> Bool 2Obtain the maximum element (if any) targeted by a ! or / Note: maximumOf on a valid 0 or # will always return  a value.  8 maximum = fromMaybe (error "empty") . maximumOf folded 9 maximumOf :: Getter a b c d -> a -> Maybe c 9 maximumOf :: Lens a b c d -> a -> Maybe c 9 maximumOf :: Ord c => Fold a b c d -> a -> Maybe c 9 maximumOf :: Ord c => Traversal a b c d -> a -> Maybe c 2Obtain the minimum element (if any) targeted by a ! or / Note: minimumOf on a valid 0 or # will always return  a value.  8 minimum = fromMaybe (error "empty") . minimumOf folded 9 minimumOf :: Getter a b c d -> a -> Maybe c 9 minimumOf :: Lens a b c d -> a -> Maybe c 9 minimumOf :: Ord c => Fold a b c d -> a -> Maybe c 9 minimumOf :: Ord c => Traversal a b c d -> a -> Maybe c 2Obtain the maximum element (if any) targeted by a !, /, 0  or #( according to a user supplied ordering.  D maximumBy cmp = fromMaybe (error "empty") . maximumByOf folded cmp J maximumByOf :: Getter a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Lens a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Fold a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c 2Obtain the minimum element (if any) targeted by a !, /, 0  or #( according to a user supplied ordering.  D minimumBy cmp = fromMaybe (error "empty") . minimumByOf folded cmp J minimumByOf :: Getter a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Lens a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Fold a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c The @ function takes a lens, a predicate and a structure and returns B the leftmost element of the structure matching the predicate, or   if there is no such element.  A variant of l4 that has no base case and thus may only be applied K to lenses and structures such that the lens views at least one element of  the structure.  . foldr1Of l f = Prelude.foldr1 f . toListOf l   foldr1 = foldr1Of folded : foldr1Of :: Getter a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Lens a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Fold a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Traversal a b c d -> (c -> c -> c) -> a -> c  A variant of mQ that has no base case and thus may only be applied to lenses and strutures such < that the lens views at least one element of the structure.  . foldl1Of l f = Prelude.foldl1Of l f . toList   foldl1 = foldl1Of folded : foldl1Of :: Getter a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Lens a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Fold a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Traversal a b c d -> (c -> c -> c) -> a -> c 6Strictly fold right over the elements of a structure.   foldr' = foldrOf' folded ? foldrOf' :: Getter a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Lens a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Fold a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Traversal a b c d -> (c -> e -> e) -> e -> a -> e NFold over the elements of a structure, associating to the left, but strictly.   foldl' = foldlOf' folded ? foldlOf' :: Getter a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Lens a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Fold a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Traversal a b c d -> (e -> c -> e) -> e -> a -> e IMonadic fold over the elements of a structure, associating to the right,  i.e. from right to left.   foldrM = foldrMOf folded N foldrMOf :: Monad m => Getter a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Lens a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Fold a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Traversal a b c d -> (c -> e -> m e) -> e -> a -> m e HMonadic fold over the elements of a structure, associating to the left,  i.e. from left to right.   foldlM = foldlMOf folded N foldlMOf :: Monad m => Getter a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Lens a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Fold a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Traversal a b c d -> (e -> c -> m e) -> e -> a -> m e BThis is the traversal that never succeeds at returning any values < traverseNothing :: Applicative f => (c -> f d) -> a -> f a ;A traversal for tweaking the left-hand value in an Either:  traverseLeft :: Applicative f < => (a -> f b) -> Either a c -> f (Either b c) ,traverse the right-hand value in an Either:   traverseRight :: Applicative f = => (a -> f b) -> Either c a -> f (Either c a)  traverseRight = traverse Unfortunately the instance for 'Traversable (Either c)' is still missing  from base, so this can' t just be  This provides a /) that checks a predicate on a key before ( allowing you to traverse into a value.  Cloning a 0) is one way to make sure you arent given  something weaker, such as a / and can be used ? as a way to pass around lenses that have to be monomorphic in f. !Note: This only accepts a proper 0 , because  lacks its $ (admissable) Applicative instance. This allows you to  the elements of a / in the  opposite order. Note: g% is similar, but is able to accept a ! (or #)  and produce a ! (or #). This requires at least a / (or 0) and can produce a  / (or 0 ) in turn. x!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~z!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~z0*/.,-+1234&'()56789:;=<>?RSTU%$A@BCEFHGIJKDL[]^_`ba\cV#!"MdefghiNOQPYZWXjklmnqropstuvwxyz{|}~u!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ RankNTypes provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedGSometimes you need to store a path lens into a container, but at least F at this time, impredicative polymorphism in GHC is somewhat lacking. FThis type provides a way to, say, store a list of polymorphic lenses. Representable Functors. A  f is  if it is isomorphic to (x -> a) > for some x. All such functors can be represented by choosing x to be ? the set of lenses that are polymorphic in the contents of the ,  that is to say  x = Rep f is a valid choice of x for every   . @Note: Some sources refer to covariant representable functors as ) corepresentable functors, and leave the " representable" name to 1 contravariant functors (those are isomorphic to (a -> x) for some x). LAs the covariant case is vastly more common, and both are often referred to = as representable functors, we choose to call these functors   here. The representation of a   as Lenses # is a valid default definition for  for a representable  functor.  $ fmapRep f m = rep $ \i -> f (m^.i) "Usage for a representable functor Foo:  instance Functor Foo where  fmap = fmapRep # is a valid default definition for  and  for a  representable functor.   pureRep = rep . const "Usage for a representable functor Foo:   instance Applicative Foo where  pure = pureRep  (<*>) = apRep  instance Monad Foo where  return = pureRep  (>>=) = bindRep # is a valid default definition for '( *)' for a representable  functor.  ) apRep mf ma = rep $ \i -> mf^.i $ ma^.i "Usage for a representable functor Foo:  instance Applicative Foo where  pure = pureRep  (<*>) = apRep + is a valid default default definition for '(>>=)' for a  representable functor.  & bindRep m f = rep $ \i -> f(m^.i)^.i "Usage for a representable functor Foo:  instance Monad ... where  return = pureRep  (>>=) = bindRep A default definition for  for a    . distributeRep wf = rep $ \i -> fmap (^.i) wf Typical Usage: ! instance Distributive ... where  distribute = distributeRep A  . has a fixed shape. This fills each position  in it with a   Map over a  " with access to the lens for the  current position ) mapWithKey f m = rep $ \i -> f i (m^.i)  Traverse a  ! with access to the current path  Traverse a  ! with access to the current path " as a lens, discarding the result  Traverse a  ! with access to the current path ( and a lens (and the arguments flipped)  over a  ! with access to the current path  as a lens  over a  ! with access to the current path " as a lens, discarding the result  over a  ! with access to the current path ( as a lens (with the arguments flipped)  Fold over a  ! with access to the current path  as a lens, yielding a   Fold over a  ! with access to the current path  as a lens. CNB: The Eq requirement on this instance is a consequence of a lens  rather than e as the representation. portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedEvaluate the targets of a 0 or / into a data structure " according to the given strategy.  * evalTraversable = evalTraversal traverse   evalTraversal = id  > evalTraversal :: Simple Lens a b -> Strategy b -> Strategy a C evalTraversal :: Simple Traversal a b -> Strategy b -> Strategy a L evalTraversal :: (b -> Eval b) -> a -> Eval a) -> Strategy b -> Strategy a Evaluate the targets of a 0 or / according into a % data structure according to a given  in parallel.  ( parTraversable = parTraversal traverse  # parTraversal l s = l (rparWith s)  = parTraversal :: Simple Lens a b -> Strategy b -> Strategy a B parTraversal :: Simple Traversal a b -> Strategy b -> Strategy a L parTraversal :: ((b -> Eval b) -> a -> Eval a) -> Strategy b -> Strategy a &MPTCs, Rank2Types, LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedAccess an element of an array. CNote: The indexed element is assumed to exist in the target array.   arr ! i = arr^.ix i " arr // [(i,e)] = ix i ^= e $ arr / ghci> ix 2 ^= 9 $ listArray (1,5) [4,5,6,7,8]  array (1,5) [4,9,6,7,8] CThis setter can be used to map over all of the values in an array. Note: 6 is strictly more general and permits more operations  amap = adjust amapped  amapped = sets amap CThis setter can be used to derive a new array from an old array by - applying a function to each of the indices.  ixmap = adjust . ixmapped  ixmapped = sets . ixmap Generic / of the elements of an array.  amap = adjust traverseArray LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedBitwise  the target(s) of a -valued 0 or % Bitwise  the target(s) of a -valued 0 or % Modify the target(s) of a . 0, % or / by computing its bitwise  with another value. Modify the target(s) of a . 0, % or / by computing its bitwise  with another value. FThis lens can be used to access the value of the nth bit in a number. bitsAt n is only a legal 0 into b if 0 <= n < bitSize (undefined :: b) *Traverse over all bits in a numeric type.  * ghci> toListOf traverseBits (5 :: Word8) 1 [True,False,True,False,False,False,False,False] %If you supply this an Integer, it won't crash, but the result will = be an infinite traversal that can be productively consumed.  ghci> toListOf traverseBits 5 K [True,False,True,False,False,False,False,False,False,False,False,False... portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered Provides ad hoc overloading for  #Traverse the individual bytes in a  H anyOf traverseByteString (==0x80) :: TraverseByteString b => b -> Bool   Haskell2010 provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered)Access the real part of a complex number ? real :: Functor f => (a -> f a) -> Complex a -> f (Complex a) .Access the imaginary part of a complex number D imaginary :: Functor f => (a -> f a) -> Complex a -> f (Complex a) This isn't quite a legal lens. Notably the view l (set l b a) = b law L is violated when you set a polar value with 0 magnitude and non-zero phase ) as the phase information is lost. So don'!t do that! Otherwise, this is a  perfectly cromulent lens. 3 polarize :: (RealFloat a, RealFloat b, Functor f) ? => ((a,a) -> f (b,b)) -> Complex a -> f (Complex b) @Traverse both the real and imaginary parts of a complex number. N traverseComplex :: Applicative f => (a -> f b) -> Complex a -> f (Complex b)  portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered(Traverse the typed value contained in a 7 where the type required by your function matches that  of the contents of the . b traverseDynamic :: (Applicative f, Typeable a, Typeable b) => (a -> f b) -> Dynamic -> f Dynamic   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 0K can be used to read, write or delete the value associated with a key in a .  0 ghci> Map.fromList [("hello",12)] ^.at "hello"  Just 12 H at :: Ord k => k -> (Maybe v -> f (Maybe v)) -> Map k v -> f (Map k v) +Traverse the value at a given key in a Map S traverseAt :: (Applicative f, Ord k) => k -> (v -> f v) -> Map k v -> f (Map k v) % traverseAt k = valueAt k . traverse /Traverse the value at the minimum key in a Map /Traverse the value at the maximum key in a Map   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 0L can be used to read, write or delete the value associated with a key in an  .  % ghci> fromList [(1,"hello")] ^.at 1  Just "hello"  % ghci> at 1 ^~ Just "hello" $ mempty  fromList [(1,"hello")] C at :: Int -> (Maybe v -> f (Maybe v)) -> IntMap v -> f (IntMap v) /Traverse the value at a given key in an IntMap N traverseAt :: Applicative f => Int -> (v -> f v) -> IntMap v -> f (IntMap v)  traverseAt k = at k . traverse /Traverse the value at the minimum key in a Map /Traverse the value at the maximum key in a Map  portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 05 can be used to read, write or delete a member of an    0 ghci> contains 3 +~ False $ fromList [1,2,3,4]  fromList [1,2,4] ; contains :: Int -> (Bool -> f Bool) -> IntSet -> f IntSet portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered A 0 that can access the nth element of a  . =Note: This is only a legal lens if there is such an element! A   is isomorphic to a    viewl m = m^.viewL A   is isomorphic to a    viewr m = m^.viewR Traverse the head of a   Traverse the tail of a   Traverse the last element of a   'Traverse all but the last element of a   Traverse the first n elements of a   Traverse all but the first n elements of a   'Travere all the elements numbered from i to j of a   portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 04 can be used to read, write or delete a member of a   4 ghci> contains 3 +~ False $ Set.fromList [1,2,3,4]  fromList [1,2,4] B contains :: Ord k => k -> (Bool -> f Bool) -> Set k -> f (Set k) portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered Provides ad hoc overloading for  for both strict and lazy . >Traverse the individual characters in a either strict or lazy . ; anyOf traverseText (=='c') :: TraverseText b => b -> Bool portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedA 0 that focuses on the root of a . A /, of the direct descendants of the root of a . portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedTraverse the strongly typed  contained in ) where the type of your function matches  the desired . @ traverseException :: (Applicative f, Exception a, Exception b) E => (a -> f b) -> SomeException -> f SomeException  !!"##$%%&''())*++,--../0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&$'($)*$+,$+-$+.$/012345$67898:;lens-1.1 Control.LensControl.Lens.THControl.Lens.InternalControl.Lens.Representable Control.Parallel.Strategies.LensData.Array.LensData.Bits.LensData.ByteString.LensData.Complex.LensData.Dynamic.Lens Data.Map.LensData.IntMap.LensData.IntSet.LensData.Sequence.Lens Data.Set.LensData.Text.LensData.Tree.LensControl.Exception.Lens Data.List transposeData.Distributive distributebaseData.Traversable TraversablesequencemapM sequenceAtraverse makeLenses makeLensesFor makeLensesBy Backwards getBackwardsMaxNoMaxMinNoMinAction getAction Traversed getTraversed AppliedStaterunAppliedState IndexedStoreFocusing unfocusinggetMingetMaxFoldGettingGetter SimpleSetterSetterFocusfocusfocus_setFocusLensLikeSimpleLensLike SimpleLensSimpleTraversalSimple TraversalLenslensiso%%~%%= traverseOfforOf sequenceAOfmapMOfforMOf sequenceOf transposeOf mapAccumROf mapAccumLOfscanr1Ofscanl1Ofmappedsetsadjustset%~^~+~*~-~//~||~&&~<>~toviewviews^$^._1_2identityresultAtwhisperqueryqueriesuseuses^=%=+=-=*=//=&&=||=<>=foldingfoldedfilteredreversed takingWhile droppingWhile foldMapOffoldOffoldrOffoldlOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOfheadOflastOfnullOf maximumOf minimumOf maximumByOf minimumByOffindOffoldr1Offoldl1OffoldrOf'foldlOf'foldrMOffoldlMOftraverseNothing traverseLeft traverseRight traverseValueclone backwardsKeyturn RepresentablerepRepfmapReppureRepapRepbindRep distributeRepkeys mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithRep evalTraversal parTraversalixamappedixmapped traverseArray|~&~&=|=bitAt traverseBitsTraverseByteStringtraverseByteStringreal imaginarypolarizetraverseComplextraverseDynamicat traverseAt traverseAtMin traverseAtMaxcontainsviewLviewR traverseHead traverseTail traverseLast traverseInit traverseTo traverseFrom traverseSlice TraverseText traverseTextrootchildrentraverseException Control.MonadmapM_GHC.BaseFunctor$fApplicativeBackwards$fFunctorBackwards $fMonoidMax $fMonoidMin$fMonoidAction$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusing Data.FoldableFoldable Data.MonoidMonoidControl.ApplicativeConst Applicative mapAccumR mapAccumLGHC.Listscanr1scanl1ghc-prim GHC.Classes|| GHC.TypesBool&&mappend mtl-2.1.2Control.Monad.Writer.Class MonadWritermemptyhead Data.MaybeJustlastTrueFalsenullNothing$fFocusReaderT $fFocusStateT$fFocusStateT0fmappurereturn$fRepresentable(->)$fRepresentableIdentityparallel-3.2.0.3Control.Parallel.StrategiesStrategy Data.Bits.|..&.bytestring-0.9.2.1Data.ByteString.Internal ByteString$fTraverseByteStringByteString$fTraverseByteStringByteString0 Data.DynamicDynamiccontainers-0.4.2.1Data.MapMap Data.IntMapIntMap Data.IntSetIntSet Data.SequenceSeqViewLViewRData.SetSet text-0.11.2.2Data.Text.InternalText$fTraverseTextText$fTraverseTextText0 Data.TreeTree GHC.Exception Exception SomeException