!"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered "Used to find the nth element of a  Traversal. 2The result of trying to find the nth element of a  Traversal.  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 (         rank 2 types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered'A concrete data type for isomorphisms. DThis lets you place an isomorphism inside a container without using ImpredicativeTypes. 7Used to provide overloading of isomorphism application  This is a ) with a canonical mapping to it from the . category of isomorphisms over Haskell types. !*Build this morphism out of an isomorphism The intention is that by using !#, you can supply both halves of an G isomorphism, but k can be instantiated to (->), so you can freely use * the resulting isomorphism as a function. "MMap a morphism in the target category using an isomorphism between morphisms  in Hask. #QAn isomorphism from a to b, overloaded to permit its use directly as a function. You can use a value of type (a :~ b) as if it were (a -> b) or Isomorphism a b. $Invert an isomorphism. ENote to compose an isomorphism and receive an isomorphism in turn you'll need to use     from (from l) = l If you imported 'Control.Category.(.)', then:   from l . from r = from (r . l)  from :: (a :~> b) -> (b :~> a) % % via :: Isomorphism a b -> (a :~> b)  !"#$% !"#$% !"$%# !"#$% Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered& 7 type SimpleIsoLike k f a b = Simple (IsoLike k f) a b ' 2 type LensLike f a b c d = IsoLike (->) f a b c d ( % type SimpleIso a b = Simple Iso a b )BIsomorphim families can be composed with other lenses using either' (.)' and  I from the Prelude or from Control.Category. However, if you compose them  with each other using '(.)'1 from the Prelude, they will be dumbed down to a  mere 9.   import Control.Category  import Prelude hiding ((.),id) Q type Iso a b c d = forall k f. (Isomorphic k, Functor f) => IsoLike k f a b c d *A *I describes how to retrieve multiple values in a way that can be composed % with other lens-like constructions. A * a cC provides a structure with operations very similar to those of the   typeclass, see v 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 c and a value of type a. A , is a legal * that just ignores the supplied   Unlike a 8 a * is read-only. Since a * cannot be used to write back $ there are no lens laws that apply. = type Fold a c = forall m b d. 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  . To be compatible with 9, 8 and ) we also : restricted choices of the irrelevant b and d parameters. If a function accepts a Getting r a b c d , then when r is a Monoid, you can  pass a * (or 8&), otherwise you can only pass this a , or 9. 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 9 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 7 ,. 8 type Getter a c = forall r. LensLike (Const r) a b c d -(This alias is supplied for those who don't want to use LiberalTypeSynonyms with  7. % 'SimpleSetter ' = 'Simple' 'Setter' . The only 9-like law that can apply to a . l is that  ! set l c (set l b a) = set l c a You can't X a .3 in general, so the other two laws are irrelevant. %However, two functor laws apply to a .   adjust l id = id , adjust l f . adjust l g = adjust l (f . g) "These an be stated more directly:   l Identity = Identity 3 l f . runIdentity . l g = l (f . runIdentity . g) You can compose a . with a 9 or a 8 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 0. on a number of different monad transformers. 0IRun a monadic action in a larger context than it was defined in, using a 7 9 or 7 8. 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 8M 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 Iso a b -> st b m c -> st a m c 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 1Like 04, but discarding any accumulated results as you go. P focus_ :: Monad m => Simple Iso a b -> st b m c -> st a m () 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 () 2A much more limited version of 0 that can work with a .. 3Many combinators that accept a 9 can also accept a 8 in limited situations. 'They do so by specializing the type of  " that they require of the caller. If a function accepts a 3 f a b c d for some   f, then they may be passed a 9.  Further, if f is an !, they may also be passed a 8. 4 - type SimpleLensLike f = Simple (LensLike f) 5  type SimpleLens = Simple Lens 6 ) type SimpleTraversal = Simple Traversal 7A 7 9, 7 8, ... can be used instead of a 9,8, ...  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 3 f or Setter, you may have to turn on  LiberalTypeSynonyms. 8A 8 can be used directly as a . or a * (but not as a 9) and provides V the ability to both read and update multiple fields, subject to some relatively weak 8 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 8 you will want to use is just , but you can also pass any  9 or )& as a Traversal, and composition of a 8 (or 9 or ) ) with a 8 (or 9 or ))  using (.) forms a valid 8. The laws for a Traversal t3 follow from the laws for Traversable as stated in "#The Essence of the Iterator Pattern". 1) Idiomatic naturality:   t pure = pure 2) Sequential composition:  : fmap (t f) . t g = getCompose . t (Compose . fmap f . g) wOne consequence of this requirement is that a traversal needs to leave the same number of elements as a candidate for * subsequent traversal as it started with. -3) No duplication of elements (as defined in "#The Essence of the Iterator Pattern" section 5.5), which states ] that you should incur no effect caused by visiting the same element of the container twice. 9A 9+ is actually a lens family as described in  /http://comonad.com/reader/2012/mirrored-lenses/. 2With great power comes great responsibility and a 91 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 9. 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 9 can be used directly as a . or 8. You can also use a 9 for + as if it were a * or ,. Since every lens is a valid 8A, the traversal laws should also apply to any lenses you create.  ) Idiomatic naturality:   l pure = pure  ) Sequential composition:  : fmap (l f) . l g = getCompose . l (Compose . fmap f . g) 7 type Lens = forall f. Functor f => LensLike f a b c d :Build a 9 from a getter and a setter. J lens :: Functor f => (a -> c) -> (a -> d -> b) -> (c -> f d) -> a -> f b ;(;') can be used in one of two scenarios: When applied to a 9 , it can edit the target of the 9 in a structure, extracting a  functorial result. When applied to a 8!, it can edit the targets of the  Traversals, extracting an % applicative summary of its actions. 8For all that the definition of this combinator is just:   (%%~) = id  G (%%~) :: Functor f => Iso a b c d -> (c -> f d) -> a -> f b G (%%~) :: Functor f => Lens a b c d -> (c -> f d) -> a -> f b G (%%~) :: Applicative f => Traversal a b c d -> (c -> f d) -> a -> f b `It may be beneficial to think about it as if it had these even more restrictive types, however: When applied to a 8!, it can edit the targets of the  Traversals, extracting a G supplemental monoidal summary of its actions, by choosing f = ((,) m) H (%%~) :: Iso a b c d -> (c -> (e, d)) -> a -> (e, b) 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) <Modify the target of a 9: in the current state returning some extra information of c or  modify all targets of a 8< in the current state, extracting extra information of type c / and return a monoidal summary of the changes.   (%%=) = (state.) It may be useful to think of (<>), instead, as having either of the following more restricted  type signatures: Q (%%=) :: MonadState a m => Iso a a c d -> (c -> (e, d) -> m e 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 =AMap 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 :: Iso a b c d -> (c -> f d) -> a -> f b ; traverseOf :: Lens a b c d -> (c -> f d) -> a -> f b ; traverseOf :: Traversal a b c d -> (c -> f d) -> a -> f b >  forOf l = flip (traverseOf l)   for = forOf traverse  forOf = morphism flip flip 1 forOf :: Lens a b c d -> a -> (c -> f d) -> f b ?FEvaluate 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 C sequenceAOf :: Iso a b (f c) c -> a -> f b C sequenceAOf :: Lens a b (f c) c -> a -> f b C sequenceAOf :: Applicative f => Traversal a b (f c) c -> a -> f b @HMap 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 :: Iso a b c d -> (c -> m d) -> a -> m b 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 A  forM = forMOf traverse  forMOf l = flip (mapMOf l) B forMOf :: Iso a b c d -> a -> (c -> m d) -> m b B forMOf :: Lens a b c d -> a -> (c -> m d) -> m b B forMOf :: Monad m => Traversal a b c d -> a -> (c -> m d) -> m b B  sequence = sequenceOf traverse  sequenceOf l = mapMOf l id * sequenceOf l = unwrapMonad . l WrapMonad < sequenceOf :: Iso a b (m c) c -> a -> m b < sequenceOf :: Lens a b (m c) c -> a -> m b < sequenceOf :: Monad m => Traversal a b (m c) c -> a -> m b CThis generalizes  to an arbitrary 8.  " transpose = transposeOf traverse  . ghci> transposeOf traverse [[1,2,3],[4,5,6]]  [[1,4],[2,5],[3,6]]  Since every 9. is a Traversal, we can use this as a form of  monadic strength. ( transposeOf _2 :: (b, [a]) -> [(b, a)] D Generalizes " to an arbitrary 8.  " mapAccumR = mapAccumROf traverse D' accumulates state from right to left. L mapAccumROf :: Iso a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) 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) E Generalized # to an arbitrary 8.  " mapAccumL = mapAccumLOf traverse E' accumulates state from left to right. L mapAccumLOf :: Iso a b c d -> (s -> c -> (s, d)) -> s -> a -> (s, b) 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) FPermit the use of $ over an arbitrary 8 or 9.   scanr1 = scanr1Of traverse : scanr1Of :: Iso a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Lens a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Traversal a b c c -> (c -> c -> c) -> a -> b GPermit the use of % over an arbitrary 8 or 9.   scanl1 = scanl1Of traverse : scanr1Of :: Iso a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Lens a b c c -> (c -> c -> c) -> a -> b : scanr1Of :: Traversal a b c c -> (c -> c -> c) -> a -> b H;This setter can be used to map over all of the values in a  .  fmap = adjust mapped  fmapDefault = adjust traverse  (<$) = set mapped IBuild a Setter.   sets . adjust = id  adjust . sets = id  sets = from adjust  adjust = from sets 0 sets :: ((c -> d) -> a -> b) -> Setter a b c d JModify the target of a 9 or all the targets of a . or 8  with a function.   fmap = adjust mapped  fmapDefault = adjust traverse   sets . adjust = id  adjust . sets = id 0 adjust :: Setter a b c d -> (c -> d) -> a -> b KModify the target of a 9 or all the targets of a . or 8 P with a function. This is an alias for adjust that is provided for consistency.   mapOf = adjust   fmap = mapOf mapped  fmapDefault = mapOf traverse   sets . mapOf = id  mapOf . sets = id 2 mapOf :: Setter a b c d -> (c -> d) -> a -> b 2 mapOf :: Iso a b c d -> (c -> d) -> a -> b 2 mapOf :: Lens a b c d -> (c -> d) -> a -> b 2 mapOf :: Traversal a b c d -> (c -> d) -> a -> b LReplace the target of a 9 or all of the targets of a .  or 8 with a constant value.   (<$) = set mapped ) set :: Setter a b c d -> d -> a -> b ) set :: Iso a b c d -> d -> a -> b ) set :: Lens a b c d -> d -> a -> b ) set :: Traversal a b c d -> d -> a -> b MModifies the target of a 9 or all of the targets of a . or  8 with a user supplied function. This is an infix version of J   fmap f = mapped %~ f  fmapDefault f = traverse %~ f  " ghci> _2 %~ length $ (1,"hello")  (1,5) 1 (%~) :: Setter a b c d -> (c -> d) -> a -> b 1 (%~) :: Iso a b c d -> (c -> d) -> a -> b 1 (%~) :: Lens a b c d -> (c -> d) -> a -> b 1 (%~) :: Traversal a b c d -> (c -> d) -> a -> b NReplace the target of a 9 or all of the targets of a .  or 8 with a constant value. This is an infix version of L , provided for consistency with '(^=)' OReplace the target of a 9 or all of the targets of a .  or 8 with a constant value. This is an infix version of L   f <$ a = mapped <~ f $ a   ghci> bitAt 0 <~ True $ 0  1 * (<~) :: Setter a b c d -> d -> a -> b * (<~) :: Iso a b c d -> d -> a -> b * (<~) :: Lens a b c d -> d -> a -> b * (<~) :: Traversal a b c d -> d -> a -> b P0Increment the target(s) of a numerically valued 9, Setter' or 8  ghci> _1 +~ 1 $ (1,2)  (2,2) Q/Multiply the target(s) of a numerically valued 9, ), . or 8  ghci> _2 *~ 4 $ (1,2)  (1,8) R0Decrement the target(s) of a numerically valued 9, ), . or 8  ghci> _1 -~ 2 $ (1,2)  (-1,2) S-Divide the target(s) of a numerically valued 9, ), . or 8 T Logically & the target(s) of a '-valued 9 or . U Logically ( the target(s) of a '-valued 9 or . V,Modify the target of a monoidally valued by )ing another value. WBuild a ,% from an arbitrary Haskell function.   to f . to g = to (g . f)  to = from view  to . from = id XView the value pointed to by a ,, ) or 9 or the result of folding over  all the results of a * or 8# that points at a monoidal values. It may be useful to think of X. as having these more restrictive signatures: 1 view :: Getter a c -> a -> c 1 view :: Monoid m => Fold a m -> a -> m 1 view :: Iso a b c d -> a -> c 1 view :: Lens a b c d -> a -> c 1 view :: Monoid m => Traversal a b m d -> a -> m YView the value of a ,, ), 9# or the result of folding over the $ result of mapping the targets of a * or 8. It may be useful to think of Y. as having these more restrictive signatures:  > views :: Getter a c -> (c -> d) -> a -> d > views :: Monoid m => Fold a c -> (c -> m) -> a -> m > views :: Iso a b c d -> (c -> d) -> a -> d > views :: Lens a b c d -> (c -> d) -> a -> d > 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 ZView the value pointed to by a ,, ) or 9 or the result of folding over  all the results of a * or 8# that points at a monoidal values. This is the same operation as X, only infix.  1 (^$) :: Getter a c -> a -> c 1 (^$) :: Monoid m => Fold a m -> a -> m 1 (^$) :: Iso a b c d -> a -> c 1 (^$) :: Lens a b c d -> a -> c 1 (^$) :: Monoid m => Traversal a b m d -> a -> m 8 (^$) :: ((c -> Const c d) -> a -> Const c b) -> a -> c [View the value pointed to by a , or 9 or the result of folding over  all the results of a * or 8# that points at a monoidal values. This is the same operation as X 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 -> Getter a c -> c 1 (^.) :: Monoid m => a -> Fold a m -> m 1 (^.) :: a -> Iso a b c d -> c 1 (^.) :: a -> Lens a b c d -> c 1 (^.) :: Monoid m => a -> Traversal a b m d -> m 8 (^.) :: a -> ((c -> Const c d) -> a -> Const c b) -> c \JThis 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) ]As \&, 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) ^A 9 to view/edit the nth element ^ a 8, 9 or ). +Attempts to access beyond the range of the 8 will cause an error. 4 ghci> [[1],[3,4]]^.elementOf (traverse.traverse) 1  3 _Access the nth element of a  container. +Attempts to access beyond the range of the 8 will cause an error.  element = elementOf traverse `HThis lens can be used to change the result of a function but only where $ the arguments match the key given. aTell a part of a value to a *, filling in the rest from + % whisper l d = tell (set l d mempty) bQuery the target of a 9, ) or , in the current state, or use a  summary of a * or 8" that points to a monoidal value.  B query :: MonadReader a m => Getter a c -> m c B query :: (MonadReader a m, Monoid c) => Fold a c -> m c B query :: MonadReader a m => Iso 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) => Traversal a b c d -> m c I query :: MonadReader a m => ((c -> Const c d) -> a -> Const c b) -> m c cUse the target of a 9, ) or , in the current state, or use a  summary of a * or 8" that points to a monoidal value.  P queries :: MonadReader a m => Getter a c -> (c -> e) -> m e P queries :: (MonadReader a m, Monoid c) => Fold a c -> (c -> e) -> m e P queries :: MonadReader a m => Iso 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) => 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 dUse the target of a 9, ), or , in the current state, or use a  summary of a * or 8" that points to a monoidal value.  ? use :: MonadState a m => Getter a c -> m c ? use :: (MonadState a m, Monoid r) => Fold a r -> m r ? use :: MonadState a m => Iso a b c d -> m c ? use :: MonadState a m => Lens a b c d -> m c ? use :: (MonadState a m, Monoid r) => Traversal a b r d -> m r F use :: MonadState a m => ((c -> Const c d) -> a -> Const c b) -> m c eUse the target of a 9, ) or , in the current state, or use a  summary of a * or 8" that points to a monoidal value.  L uses :: MonadState a m => Getter a c -> (c -> e) -> m e L uses :: (MonadState a m, Monoid r) => Fold a c -> (c -> r) -> m r L uses :: MonadState a m => Lens a b c d -> (c -> e) -> m e L uses :: MonadState a m => Iso a b c d -> (c -> e) -> m e L uses :: (MonadState a m, Monoid r) => Traversal a b c d -> (c -> r) -> m r S uses :: MonadState a m => ((c -> Const e d) -> a -> Const e b) -> (c -> e) -> m e fReplace the target of a 9 or all of the targets of a . or 8 in our monadic 2 state with a new value, irrespective of the old. : (^=) :: MonadState a m => Iso a a c d -> d -> m () : (^=) :: MonadState a m => Lens a a c d -> d -> m () : (^=) :: MonadState a m => Traversal a a c d -> d -> m () : (^=) :: MonadState a m => Setter a a c d -> d -> m () gMap over the target of a 9 or all of the targets of a . or ' Traversal in our monadic state. A (%=) :: MonadState a m => Iso a a c d -> (c -> d) -> m () A (%=) :: MonadState a m => Lens a a c d -> (c -> d) -> m () A (%=) :: MonadState a m => Traversal a a c d -> (c -> d) -> m () A (%=) :: MonadState a m => Setter a a c d -> (c -> d) -> m () hModify the target(s) of a 7 9, ), . or 8 by adding a value  Example:  fresh = do  id += 1  access id iModify the target(s) of a 7 9, ), . or 8 by subtracting a value jModify the target(s) of a 7 9, ), . or 8 by multiplying by value kModify the target(s) of a 7 9, ), . or 8 by dividing by a value lModify the target(s) of a 7 9, ), . or 8 by taking their logical ( with a value mModify the target(s) of a 7 9, 'Iso, . or 8 by taking their logical & with a value nModify the target(s) of a 7 9, ), . or 8 by ) ing a value. oBuild a , or * from a ,-like function. E folds :: ((c -> m) -> a -> m) -> (c -> Const m d) -> a -> Const m b 4 folds :: ((c -> m) -> a -> m) -> Getting m a b c d p 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 *. q Obtain a * from any .  folded = folds foldMap r Obtain a * by filtering a 9, ), ,, * or 8. s Obtain a *+ by reversing the order of traversal for a 9, ), ,, * or 8. Of course, reversing a 9, ) or , has no effect. t Obtain a *! by taking elements from another *, 9, ), , or 8 while a predicate holds.  / takeWhile p = toListOf (takingWhile p folded) / ghci> toList (takingWhile (<=3) folded) [1..]  [1,2,3] u Obtain a *# by dropping elements from another *, 9, ), , or 8 while a predicate holds.  1 dropWhile p = toListOf (droppingWhile p folded) . ghci> toList (dropWhile (<=3) folded) [1..6]  [4,5,6] v  foldMap = foldMapOf folded   foldMapOf = views  foldMapOf = from folds  B foldMapOf :: Getter a c -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Fold a c -> (c -> m) -> a -> m B foldMapOf :: Lens a b c d -> (c -> m) -> a -> m B foldMapOf :: Iso a b c d -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Traversal a b c d -> (c -> m) -> a -> m 6 foldMapOf :: Getting m a b c d -> (c -> m) -> a -> m w  fold = foldOf folded   foldOf = view 3 foldOf :: Getter a m -> a -> m 3 foldOf :: Monoid m => Fold a m -> a -> m 3 foldOf :: Lens a b m d -> a -> m 3 foldOf :: Iso a b m d -> a -> m 3 foldOf :: Monoid m => Traversal a b m d -> a -> m xIRight-associative fold of parts of a structure that are viewed through a 9, ,, * or 8.   foldr = foldrOf folded > foldrOf :: Getter a c -> (c -> e -> e) -> e -> a -> e > foldrOf :: Fold a c -> (c -> e -> e) -> e -> a -> e > foldrOf :: Lens a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Iso a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Traversal a b c d -> (c -> e -> e) -> e -> a -> e yLLeft-associative fold of the parts of a structure that are viewed through a 9, ,, * or 8.   foldl = foldlOf folded > foldlOf :: Getter a c -> (e -> c -> e) -> e -> a -> e > foldlOf :: Fold a c -> (e -> c -> e) -> e -> a -> e > foldlOf :: Lens a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Iso a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Traversal a b c d -> (e -> c -> e) -> e -> a -> e z  toList = toListOf folded + toListOf :: Getter a c -> a -> [c] + toListOf :: Fold a c -> a -> [c] + toListOf :: Lens a b c d -> a -> [c] + toListOf :: Iso a b c d -> a -> [c] + toListOf :: Traversal a b c d -> a -> [c] {  and = andOf folded + andOf :: Getter a Bool -> a -> Bool + andOf :: Fold a Bool -> a -> Bool + andOf :: Lens a b Bool d -> a -> Bool + andOf :: Iso a b Bool d -> a -> Bool + andOf :: Traversl a b Bool d -> a -> Bool |  or = orOf folded + orOf :: Getter a Bool -> a -> Bool + orOf :: Fold a Bool -> a -> Bool + orOf :: Lens a b Bool d -> a -> Bool + orOf :: Iso a b Bool d -> a -> Bool + orOf :: Traversal a b Bool d -> a -> Bool }  any = anyOf folded 8 anyOf :: Getter a c -> (c -> Bool) -> a -> Bool 8 anyOf :: Fold a c -> (c -> Bool) -> a -> Bool 8 anyOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Iso a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool ~  all = allOf folded 8 allOf :: Getter a c -> (c -> Bool) -> a -> Bool 8 allOf :: Fold a c -> (c -> Bool) -> a -> Bool 8 allOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Iso a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool   product = productOf folded 3 productOf :: Getter a c -> a -> c 3 productOf :: Num c => Fold a c -> a -> c 3 productOf :: Lens a b c d -> a -> c 3 productOf :: Iso a b c d -> a -> c 3 productOf :: Num c => Traversal a b c d -> a -> c   sum = sumOf folded   sumOf _1 :: (a, b) -> a ; sumOf (folded._1) :: (Foldable f, Num a) => f (a, b) -> a / sumOf :: Getter a c -> a -> c / sumOf :: Num c => Fold a c -> a -> c / sumOf :: Lens a b c d -> a -> c / sumOf :: Iso a b c d -> a -> c / sumOf :: Num c => Traversal a b c d -> a -> c When passed a ,,  can work over a  . When passed a *,  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 c -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Fold a c -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Lens a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Iso a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Traversal a b c d -> (c -> f e) -> a -> f ()   for_ = forOf_ folded I forOf_ :: Functor f => Getter a c -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Fold a c -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Lens a b c d -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Iso a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Traversal a b c d -> a -> (c -> f e) -> f ()  " sequenceA_ = sequenceAOf_ folded F sequenceAOf_ :: Functor f => Getter a (f ()) -> a -> f () F sequenceAOf_ :: Applicative f => Fold a (f ()) -> a -> f () F sequenceAOf_ :: Functor f => Lens a b (f ()) d -> a -> f () F sequenceAOf_ :: Functor f => Iso a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Traversal a b (f ()) d -> a -> f ()   mapM_ = mapMOf_ folded D mapMOf_ :: Monad m => Getter a c -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Fold a c -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Lens a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Iso a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Traversal a b c d -> (c -> m e) -> a -> m ()   forM_ = forMOf_ folded D forMOf_ :: Monad m => Getter a c -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Fold a c -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Lens a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Iso a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Traversal a b c d -> a -> (c -> m e) -> m ()   sequence_ = sequenceOf_ folded > sequenceOf_ :: Monad m => Getter a (m b) -> a -> m () > sequenceOf_ :: Monad m => Fold a (m b) -> a -> m () > sequenceOf_ :: Monad m => Lens a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Iso 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 c -> a -> f c : asumOf :: Alternative f => Fold a c -> a -> f c : asumOf :: Alternative f => Lens a b c d -> a -> f c : asumOf :: Alternative f => Iso 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 c -> a -> m c 8 msumOf :: MonadPlus m => Fold a c -> a -> m c 8 msumOf :: MonadPlus m => Lens a b c d -> a -> m c 8 msumOf :: MonadPlus m => Iso 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 c -> c -> a -> Bool 7 elemOf :: Eq c => Fold a c -> c -> a -> Bool 7 elemOf :: Eq c => Lens a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Iso 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 c -> c -> a -> Bool : notElemOf :: Eq c => Fold a c -> c -> a -> Bool : notElemOf :: Eq c => Iso 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 c -> (c -> [e]) -> a -> [e] < concatMapOf :: Fold a c -> (c -> [e]) -> a -> [e] < concatMapOf :: Lens a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Iso a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Traversal a b c d -> (c -> [e]) -> a -> [e]   concat = concatOf folded - concatOf :: Getter a [e] -> a -> [e] - concatOf :: Fold a [e] -> a -> [e] - concatOf :: Iso a b [e] d -> a -> [e] - concatOf :: Lens a b [e] d -> a -> [e] - concatOf :: Traversal 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 c -> a -> Int + lengthOf :: Fold a c -> a -> Int + lengthOf :: Lens a b c d -> a -> Int + lengthOf :: Iso a b c d -> a -> Int + lengthOf :: Traversal a b c d -> a -> Int Perform a safe - of a * or 8 or retrieve . the result  from a , or 9.  & listToMaybe . toList = headOf folded - headOf :: Getter a c -> a -> Maybe c - headOf :: Fold a c -> a -> Maybe c - headOf :: Lens a b c d -> a -> Maybe c - headOf :: Iso a b c d -> a -> Maybe c - headOf :: Traversal a b c d -> a -> Maybe c Perform a safe / of a * or 8 or retrieve . the result  from a , or 9. - lastOf :: Getter a c -> a -> Maybe c - lastOf :: Fold a c -> a -> Maybe c - lastOf :: Lens a b c d -> a -> Maybe c - lastOf :: Iso a b c d -> a -> Maybe c - lastOf :: Traversal a b c d -> a -> Maybe c Returns 0 if this * or 8( has no targets in the given container. Note: nullOf on a valid ), 9 or , should always return 1   null = nullOf folded /This may be rather inefficient compared to the 2 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 c -> a -> Bool * nullOf :: Fold a c -> a -> Bool * nullOf :: Iso a b c d -> a -> Bool * nullOf :: Lens a b c d -> a -> Bool * nullOf :: Traversal a b c d -> a -> Bool 2Obtain the maximum element (if any) targeted by a * or 8 Note: maximumOf on a valid ), 9 or , will always return . a value.  8 maximum = fromMaybe (error "empty") . maximumOf folded 9 maximumOf :: Getter a c -> a -> Maybe c 9 maximumOf :: Ord c => Fold a c -> a -> Maybe c 9 maximumOf :: Iso a b c d -> a -> Maybe c 9 maximumOf :: Lens 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 8 Note: minimumOf on a valid ), 9 or , will always return . a value.  8 minimum = fromMaybe (error "empty") . minimumOf folded 9 minimumOf :: Getter a c -> a -> Maybe c 9 minimumOf :: Ord c => Fold a c -> a -> Maybe c 9 minimumOf :: Iso a b c d -> a -> Maybe c 9 minimumOf :: Lens 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 *, 8, 9, ),  or ,( according to a user supplied ordering.  D maximumBy cmp = fromMaybe (error "empty") . maximumByOf folded cmp J maximumByOf :: Getter a c -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Fold a c -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Iso 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 :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c 2Obtain the minimum element (if any) targeted by a *, 8, 9, )  or ,( according to a user supplied ordering.  D minimumBy cmp = fromMaybe (error "empty") . minimumByOf folded cmp J minimumByOf :: Getter a c -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Fold a c -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Iso 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 :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c The ? function takes a lens (or , getter, iso, fold, or traversal), O a predicate and a structure and returns the leftmost element of the structure  matching the predicate, or 3 if there is no such element. < findOf :: Getter a c -> (c -> Bool) -> a -> Maybe c < findOf :: Fold a c -> (c -> Bool) -> a -> Maybe c < findOf :: Iso a b c d -> (c -> Bool) -> a -> Maybe c < findOf :: Lens a b c d -> (c -> Bool) -> a -> Maybe c < findOf :: Traversal a b c d -> (c -> Bool) -> a -> Maybe c  A variant of x4 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 c -> (c -> c -> c) -> a -> c : foldr1Of :: Fold a c -> (c -> c -> c) -> a -> c : foldr1Of :: Iso a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Lens a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Traversal a b c d -> (c -> c -> c) -> a -> c  A variant of yQ 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 c -> (c -> c -> c) -> a -> c : foldl1Of :: Fold a c -> (c -> c -> c) -> a -> c : foldl1Of :: Iso a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Lens 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 c -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Fold a c -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Iso a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Lens 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 A foldlOf' :: Getter a c -> (e -> c -> e) -> e -> a -> e A foldlOf' :: Fold a c -> (e -> c -> e) -> e -> a -> e A foldlOf' :: Iso a b c d -> (e -> c -> e) -> e -> a -> e A foldlOf' :: Lens a b c d -> (e -> c -> e) -> e -> a -> e A 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 c -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Fold a c -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Iso 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 => 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 c -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Fold a c -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Iso 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 => 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: M traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f (Either b c) ,traverse the right-hand value in an Either:   traverseRight = traverse Unfortunately the instance for 'Traversable (Either c)' is still missing  from base, so this can' t just be  N traverseRight :: Applicative f => (a -> f b) -> Either c a -> f (Either c a) This provides a 8) that checks a predicate on a key before ( allowing you to traverse into a value. This allows you to  the elements of a 8 in the  opposite order. Note: s% is similar, but is able to accept a * (or ,)  and produce a * (or ,). This requires at least a 8 (or 9) and can produce a  8 (or 9 ) in turn.  A backwards ) is the same )". If you reverse the direction of  the isomorphism use $ instead. 9Merge two lenses, getters, setters, folds or traversals. 6 makes a lens from two other lenses (or isomorphisms) @Build an isomorphism family from two pairs of inverse functions E isos :: (a -> c) -> (c -> a) -> (b -> d) -> (d -> b) -> Iso a b c d <Build a simple isomorphism from a pair of inverse functions / iso :: (a -> b) -> (b -> a) -> Simple Iso a b :This isomorphism can be used to wrap or unwrap a value in 4.  x^.identity = Identity x  Identity x^.from identity = x :This isomorphism can be used to wrap or unwrap a value in    x^.konst = Const x  Const x^.from konst = x  Cloning a 9) is one way to make sure you arent given  something weaker, such as a 8 and can be used ? as a way to pass around lenses that have to be monomorphic in f. !Note: This only accepts a proper 9 , because  lacks its $ (admissable) Applicative instance. &'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~567 !"$&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~9387564;<:\]`_^)('& !"$.-IHJKLaNMOfg,*+WopqrstuXY[Zdebcvwxyz}~{|PRQSTUVhijkmln/012=>?@ABCEDFG&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~567 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 8 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 9 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   A version of 5 that is an isomorphism. Predicativity requires that  we wrap the  as a  , however.  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-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 LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedBitwise @ the target(s) of a '-valued 9 or . Bitwise A the target(s) of a '-valued 9 or . Modify the target(s) of a 7 9, . or 8 by computing its bitwise A with another value. Modify the target(s) of a 7 9, . or 8 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 9 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...  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. @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 B7 where the type required by your function matches that  of the contents of the B. b traverseDynamic :: (Applicative f, Typeable a, Typeable b) => (a -> f b) -> Dynamic -> f Dynamic   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 9L can be used to read, write or delete the value associated with a key in an C.  % 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 95 can be used to read, write or delete a member of an D  0 ghci> contains 3 +~ False $ fromList [1,2,3,4]  fromList [1,2,4] ; contains :: Int -> (Bool -> f Bool) -> IntSet -> f IntSet This .* can be used to change the contents of an D by mapping  the elements to new values. Sadly, you can't create a valid 8 for a Set, because the number of B elements might change but you can manipulate it by reading using q and  reindexing it via setmap. / ghci> adjust members (+1) (fromList [1,2,3,4]  fromList [2,3,4,5]  Construct an D from a ,, *, 8, 9 or ). - setOf :: Getter a Int -> a -> IntSet - setOf :: Fold a Int -> a -> IntSet - setOf :: Iso a b Int d -> a -> IntSet - setOf :: Lens a b Int d -> a -> IntSet - setOf :: Traversal a b Int d -> a -> IntSet   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 9K can be used to read, write or delete the value associated with a key in a E.  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  portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered A 9 that can access the nth element of a F. =Note: This is only a legal lens if there is such an element! A F is isomorphic to a G  viewl m = m^.viewL A F is isomorphic to a H  viewr m = m^.viewR Traverse the head of a F Traverse the tail of a F Traverse the last element of a F 'Traverse all but the last element of a F Traverse the first n elements of a F Traverse all but the first n elements of a F 'Travere all the elements numbered from i to j of a F portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis 94 can be used to read, write or delete a member of a I  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) This .% can be used to change the type of a I by mapping  the elements to new values. Sadly, you can't create a valid 8 for a I, but you can  manipulate it by reading using q and reindexing it via setmap. / ghci> adjust members (+1) (fromList [1,2,3,4]  fromList [2,3,4,5] Construct a set from a ,, *, 8, 9 or ). 3 setOf :: Getter a c -> a -> Set c 3 setOf :: Ord c => Fold a c -> a -> Set c 3 setOf :: Iso a b c d -> a -> Set c 3 setOf :: Lens a b c d -> a -> Set c 3 setOf :: Ord c => Traversal a b c d -> a -> Set c portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedA 9 that focuses on the root of a J. A 8, of the direct descendants of the root of a J. TemplateHaskell experimentalEdward Kmett <ekmett@gmail.com>None Provides substitution for types Perform substitution for types HProvides for the extraction of free type variables, and alpha renaming. 4When performing substitution into this traversal you're not allowed 8 to substitute in a name that is bound internally or you' ll violate  the 8. laws, when in doubt generate your names with K. Has a L Extract (or modify) the L of something  Traverse free type variables 'Substitute using a map of names in for free type variables MNOPQRSTUVWMNOPQRSTUVWTemplateHaskell experimentalEdward Kmett <ekmett@gmail.com> Trustworthy+This configuration describes the options we'+ll be using to make isomorphisms or lenses RLens to access the convention for naming top level isomorphisms in our lens rules BLens to access the convention for naming fields in our lens rules Default lens rules )Build lenses with a custom configuration 3Build lenses with a sensible default configuration /Derive lenses, specifying explicit pairings of (fieldName, lensName). Example usage: < makeLensesFor [("_foo", "fooLens"), ("bar", "lbar")] ''Foo &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.  This is a  contravariant Setter.   ixmap = adjust . ixmapped  ixmapped = sets . ixmap + adjust (ixmapped b) f arr ! i = arr ! f i ( bounds (adjust (ixmapped b) f arr) = b Generic 8 of the elements of an array.  amap = adjust traverseArray portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered(Pack (or unpack) a list of bytes into a X  pack x = x^.packedBytes  unpack x = x^.from packedBytes #Traverse the individual bytes in a X  % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool -Pack (or unpack) a list of characters into a X FWhen writing back to the byteString it is assumed that all characters  lie between '\x00' and '\xff'.  pack x = x^.packedChars  unpack x = x^.from packedChars #Traverse the individual bytes in a X as characters. FWhen writing back to the byteString it is assumed that all characters  lie between '\x00' and '\xff'.   chars = from packed . traverse + anyOf chars (=='c') :: ByteString -> Bool portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered(Pack (or unpack) a list of bytes into a Y  pack x = x^.packedBytes  unpack x = x^.from packedBytes #Traverse the individual bytes in a Y  % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool -Pack (or unpack) a list of characters into a Y FWhen writing back to the byteString it is assumed that all characters  lie between '\x00' and '\xff'.  pack x = x^.packedChars  unpack x = x^.from packedChars #Traverse the individual bytes in a Y as characters. FWhen writing back to the byteString it is assumed that all characters  lie between '\x00' and '\xff'.   chars = from packed . traverse + anyOf chars (=='c') :: ByteString -> Bool portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedPack (or unpack) Z.  pack x = x^.packed  unpack x = x^.from packed >Traverse the individual characters in a either strict or lazy Z. $ anyOf text (=='c') :: Text -> Bool portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedPack (or unpack) [.  pack x = x^.packed  unpack x = x^.from packed (Traverse the individual characters in a [. $ anyOf text (=='c') :: Text -> Bool portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedEvaluate the targets of a 9 or 8 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 9 or 8 according into a % data structure according to a given \ in parallel.  ( parTraversable = parTraversal traverse  = 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  Transform a 9, *, ,, . or 8 to P first evaluates its argument according to a given strategy, before proceeding.  after rdeepseq traverse  Transform a 9, *, ,, . or 8 to R evaluate its argument according to a given strategy in parallel with evaluating.  meanwhile rdeepseq traverse portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedDEvaluate the elements targeted by a Lens, Traversal, Getter or Fold " according to the given strategy.  seqFoldable = seqOf folded GHC experimentalEdward Kmett <ekmett@gmail.com> Safe-Infered ;Convert from the data type to its representation (or back)  ;Convert from the data type to its representation (or back)         ] !!"#$%&&'(()**+,,-../0011234556789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~        !"#$%!&'()*+,+-./0102345367348)9:;<)='>0?@A0B36C36D0E@FGHIJKLM+NOPQRSTSUVWVXYZ[\][^_[`a[bc[bd[be[fg[hijkljkmnopqrstuvwxyz{y|{}~}lens-1.3 Control.LensControl.Lens.InternalControl.IsomorphicControl.Lens.RepresentableControl.Exception.LensData.Bits.LensData.Complex.LensData.Dynamic.LensData.IntMap.LensData.IntSet.Lens Data.Map.LensData.Sequence.Lens Data.Set.LensData.Tree.LensLanguage.Haskell.TH.LensControl.Lens.THData.Array.LensData.ByteString.LensData.ByteString.Lazy.LensData.Text.LensData.Text.Lazy.Lens Control.Parallel.Strategies.LensControl.Seq.LensGHC.Generics.Lens Data.List transposeData.Distributive distributebaseData.Traversable Traversabletraverse ElementOf getElementOfElementOfResultFound SearchingMaxNoMaxMinNoMinAction getAction Traversed getTraversed AppliedStaterunAppliedState IndexedStoreFocusing unfocusinggetMingetMax Isomorphism Isomorphic isomorphicisomap:~>fromvia SimpleIsoLikeIsoLike SimpleIsoIsoFoldGettingGetter SimpleSetterSetterFocusfocusfocus_setFocusLensLikeSimpleLensLike SimpleLensSimpleTraversalSimple TraversalLenslens%%~%%= traverseOfforOf sequenceAOfmapMOfforMOf sequenceOf transposeOf mapAccumROf mapAccumLOfscanr1Ofscanl1OfmappedsetsadjustmapOfset%~^~<~+~*~-~//~||~&&~<>~toviewviews^$^._1_2 elementOfelementresultAtwhisperqueryqueriesuseuses^=%=+=-=*=//=&&=||=<>=foldsfoldingfoldedfilteredreversed takingWhile droppingWhile foldMapOffoldOffoldrOffoldlOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOfheadOflastOfnullOf maximumOf minimumOf maximumByOf minimumByOffindOffoldr1Offoldl1OffoldrOf'foldlOf'foldrMOffoldlMOftraverseNothing traverseLeft traverseRight traverseValue backwardsmerged bothLensesisosisoidentitykonstcloneKeyturn RepresentablerepRepfmapReppureRepapRepbindRep distributeRepkeys tabulated mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithReptraverseException|~&~&=|=bitAt traverseBitsreal imaginarypolarizetraverseComplextraverseDynamicat traverseAt traverseAtMin traverseAtMaxcontainsmemberssetOfviewLviewR traverseHead traverseTail traverseLast traverseInit traverseTo traverseFrom traverseSlicerootchildren SubstType substType HasTypeVars typeVarsExHasNamenametypeVars substTypeVars LensRules isoLensRule fieldLensRuledefaultLensRulesmakeLensesWith makeLenses makeLensesForixamappedixmapped traverseArray packedBytesbytes packedCharscharspackedtextevalOfparOfafter meanwhileseqOfgenericgeneric1 Control.MonadmapM_GHC.BaseFunctor$fApplicativeElementOf$fFunctorElementOf$fFunctorElementOfResult $fMonoidMax $fMonoidMin$fMonoidAction$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusingControl.CategoryCategory$fIsomorphicIsomorphism$fCategoryIsomorphism$fIsomorphic(->)id Data.FoldableFoldable Data.MonoidMonoidControl.ApplicativeConst Applicative mapAccumR mapAccumLGHC.Listscanr1scanl1ghc-prim GHC.Classes|| GHC.TypesBool&&mappend mtl-2.1.2Control.Monad.Writer.Class MonadWritermemptyfoldMaphead Data.MaybeJustlastTrueFalsenullNothingtransformers-0.3.0.0Data.Functor.IdentityIdentity$fFocusReaderT $fFocusStateT$fFocusStateT0fmappurereturnmapM$fRepresentable(->)$fRepresentableIdentity GHC.Exception Exception SomeException Data.Bits.|..&. Data.DynamicDynamiccontainers-0.4.2.1 Data.IntMapIntMap Data.IntSetIntSetData.MapMap Data.SequenceSeqViewLViewRData.SetSet Data.TreeTreetemplate-haskellLanguage.Haskell.TH.SyntaxnewNameName$fSubstTypePred $fSubstType[]$fSubstTypeType$fHasTypeVars[]$fHasTypeVarsPred$fHasTypeVarsType$fHasTypeVarsName$fHasTypeVarsTyVarBndr $fHasNameCon $fHasNameName$fHasNameTyVarBndrbytestring-0.9.2.1Data.ByteString.Internal ByteStringData.ByteString.Lazy.Internal text-0.11.2.2Data.Text.InternalTextData.Text.Lazy.Internalparallel-3.2.0.3Control.Parallel.StrategiesStrategy