.د?      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~       !"#$%&'()*+,-./0123456789:;<=> 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 ( ABCDEFGHIJKL     ABCDEFGHIJKL 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 M) 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  M   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)  !"#$%NOP !"#$% !"$%# !"#$%NOP"rank 2 types, MPTCs, TFs, flexible provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered&YA function with access to a index. This constructor may be useful when you need to store  a HasIndex. )=Type alias for passing around polymorphic indexed functions. *bPermit overloading of function application for things that also admit a notion of a key or index. ,Provides overloading for indexed functions. +*Build a function from an indexed function ,Remap the index. -!Composition of indexed functions .TComposition of indexed functions with a user supplied function for combining indexs QCUsing an equality witness to avoid potential overlapping instances  and aid dispatch. &'()*+,-.QR &'()*+,-. *+)&'(-.,&'()*+,-.QR Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered/ type 'SimpleIdexedTraversal i = C (0 i)0>Every indexed traversal is a valid Traversal or indexed fold. XThe Traversal laws are still required to hold. Moreover, each index should be distinct. 1Every 1 is a valid 6 2 % type SimpleIso a b = Simple Iso a b 3BIsomorphim families can be composed with other lenses using either' (.)' and S 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 E.   import Control.Category  import Prelude hiding ((.),id) T type Iso a b c d = forall k f. (Isomorphic k, Functor f) => Overloaded k f a b c d 4 = type SimpleOverloaded k f a b = Simple (Overloaded k f) a b 5 5 type LensLike f a b c d = Overloaded (->) f a b c d 6A 6I describes how to retrieve multiple values in a way that can be composed % with other lens-like constructions. A 6 a cC provides a structure with operations very similar to those of the T  typeclass, see  and the other 6 combinators. !By convention, if there exists a foo method that expects a T (f c), then there should be a  fooOf method that takes a 6 a c and a value of type a. A 8 is a legal 6 that just ignores the supplied U  Unlike a D a 6 is read-only. Since a 6 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 7Most 8- combinators are able to be used with both a 8 or a 6 in S limited situations, to do so, they need to be monomorphic in what we are going to  extract with V. To be compatible with E, D and 3 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 6 (or D&), otherwise you can only pass this a 8 or E. 5 type Getting r a b c d = LensLike (Const r) a b c d 8A 8M describes how to retrieve a single value in a way that can be composed with  other lens-like constructions.  Unlike a E a 8 is read-only. Since a 8 cannot be used to write back 3 there are no lens laws that can be applied to it.  Moreover, a 8 can be used directly as a 6, since it just ignores the U. In practice the b and d? are left dangling and unused, and as such is no real point in  using a C 8. 8 type Getter a c = forall r. LensLike (Const r) a b c d 9(This alias is supplied for those who don't want to use LiberalTypeSynonyms with  C. % 'SimpleSetter ' = 'Simple' 'Setter' : The only E-like law that can apply to a : l is that  ! set l c (set l b a) = set l c a You can't d 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 E or a D 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 C E or C D. 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 DM 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 =Like <4, 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 () >A much more limited version of < that can work with a :. ?Many combinators that accept a E can also accept a D 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 E.  Further, if f is an W, they may also be passed a D. @ - type SimpleLensLike f = Simple (LensLike f) A  type SimpleLens = Simple Lens B ) type SimpleTraversal = Simple Traversal CA C E, C D, ... can be used instead of a E,D, ...  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. DA D can be used directly as a : or a 6 (but not as a E) and provides V the ability to both read and update multiple fields, subject to some relatively weak D 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 D you will want to use is just , but you can also pass any  E or 3& as a Traversal, and composition of a D (or E or 3 ) with a D (or E or 3)  using (.) forms a valid D. 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. EA E+ is actually a lens family as described in  /http://comonad.com/reader/2012/mirrored-lenses/. 2With great power comes great responsibility and a E1 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 E. 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 E can be used directly as a : or D. You can also use a E for 7 as if it were a 6 or 8. Since every lens is a valid DA, 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 FBuild a E from a getter and a setter. J lens :: Functor f => (a -> c) -> (a -> d -> b) -> (c -> f d) -> a -> f b G(G') can be used in one of two scenarios: When applied to a E , it can edit the target of the E in a structure, extracting a  functorial result. When applied to a D!, 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 D!, 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) HModify the target of a E: in the current state returning some extra information of c or  modify all targets of a D< 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 (H>), 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 IAMap 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 J  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 KFEvaluate 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 LHMap 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 M  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 N  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 OThis generalizes  to an arbitrary D.  " transpose = transposeOf traverse  . ghci> transposeOf traverse [[1,2,3],[4,5,6]]  [[1,4],[2,5],[3,6]]  Since every E. is a Traversal, we can use this as a form of  monadic strength. ( transposeOf _2 :: (b, [a]) -> [(b, a)] P Generalizes X to an arbitrary D.  " mapAccumR = mapAccumROf traverse P' 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) Q Generalized Y to an arbitrary D.  " mapAccumL = mapAccumLOf traverse Q' 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) RPermit the use of Z over an arbitrary D or E.   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 SPermit the use of [ over an arbitrary D or E.   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 T;This setter can be used to map over all of the values in a @.  fmap = adjust mapped  fmapDefault = adjust traverse  (<$) = set mapped UBuild 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 VModify the target of a E or all the targets of a : or D  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 WModify the target of a E or all the targets of a : or D 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 XReplace the target of a E or all of the targets of a :  or D 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 YModifies the target of a E or all of the targets of a : or  D with a user supplied function. This is an infix version of V   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 ZReplace the target of a E or all of the targets of a :  or D with a constant value. This is an infix version of X , provided for consistency with '(^=)' [Replace the target of a E or all of the targets of a :  or D with a constant value. This is an infix version of X   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 \0Increment the target(s) of a numerically valued E, Setter' or D  ghci> _1 +~ 1 $ (1,2)  (2,2) ]/Multiply the target(s) of a numerically valued E, 3, : or D  ghci> _2 *~ 4 $ (1,2)  (1,8) ^0Decrement the target(s) of a numerically valued E, 3, : or D  ghci> _1 -~ 2 $ (1,2)  (-1,2) _-Divide the target(s) of a numerically valued E, 3, : or D ` Logically \ the target(s) of a ]-valued E or : a Logically ^ the target(s) of a ]-valued E or : b,Modify the target of a monoidally valued by _ing another value. cBuild a 8% from an arbitrary Haskell function.   to f . to g = to (g . f)  to = from view  to . from = id dView the value pointed to by a 8, 3 or E or the result of folding over  all the results of a 6 or D# that points at a monoidal values. It may be useful to think of d. 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 eView the value of a 8, 3, E# or the result of folding over the $ result of mapping the targets of a 6 or D. It may be useful to think of e. 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 fView the value pointed to by a 8, 3 or E or the result of folding over  all the results of a 6 or D# that points at a monoidal values. This is the same operation as d, 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 gView the value pointed to by a 8 or E or the result of folding over  all the results of a 6 or D# that points at a monoidal values. This is the same operation as d 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 hJThis 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) iAs h&, 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) jA E to view/edit the nth element j a D, E or 3. +Attempts to access beyond the range of the D will cause an error. 4 ghci> [[1],[3,4]]^.elementOf (traverse.traverse) 1  3 kAccess the nth element of a  container. +Attempts to access beyond the range of the D will cause an error.  element = elementOf traverse lHThis lens can be used to change the result of a function but only where $ the arguments match the key given. mTell a part of a value to a `, filling in the rest from a % whisper l d = tell (set l d mempty) nQuery the target of a E, 3 or 8 in the current state, or use a  summary of a 6 or D" 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 oUse the target of a E, 3 or 8 in the current state, or use a  summary of a 6 or D" 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 pUse the target of a E, 3, or 8 in the current state, or use a  summary of a 6 or D" 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 qUse the target of a E, 3 or 8 in the current state, or use a  summary of a 6 or D" 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 rReplace the target of a E or all of the targets of a : or D 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 () sMap over the target of a E 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 () tModify the target(s) of a C E, 3, : or D by adding a value  Example:  fresh = do  id += 1  access id uModify the target(s) of a C E, 3, : or D by subtracting a value vModify the target(s) of a C E, 3, : or D by multiplying by value wModify the target(s) of a C E, 3, : or D by dividing by a value xModify the target(s) of a C E, 3, : or D by taking their logical ^ with a value yModify the target(s) of a C E, 'Iso, : or D by taking their logical \ with a value zModify the target(s) of a C E, 3, : or D by _ ing a value. {Build a 8 or 6 from a b-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 | Obtain a 69 by lifting an operation that returns a foldable result. +This can be useful to lift operations from  Data.List and elsewhere into a 6. } Obtain a 6 from any T.  folded = folds foldMap ~%Fold by repeating the input forever.  repeat = toListOf repeated !A fold that replicates its input n times. ' replicate n = toListOf (replicated n) ITransform a fold into a fold that loops over its elements over and over. * ghci> toListOf (cycled traverse) [1,2,3]  [1,2,3,1,2,3,..] 2Build a fold that unfolds its values from a seed. % ghci> unfoldr = toListOf . unfolded x ^.  f5 Return an infinite fold of repeated applications of f to x. ' toListOf (iterated f) a = iterate f a  Obtain a 6 by filtering a E, 3, 8, 6 or D.  Obtain a 6+ by reversing the order of traversal for a E, 3, 8, 6 or D. Of course, reversing a E, 3 or 8 has no effect.  Obtain a 6! by taking elements from another 6, E, 3, 8 or D while a predicate holds.  / takeWhile p = toListOf (takingWhile p folded) / ghci> toList (takingWhile (<=3) folded) [1..]  [1,2,3]  Obtain a 6# by dropping elements from another 6, E, 3, 8 or D while a predicate holds.  1 dropWhile p = toListOf (droppingWhile p folded) . ghci> toList (dropWhile (<=3) folded) [1..6]  [4,5,6]   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   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 IRight-associative fold of parts of a structure that are viewed through a E, 8, 6 or D.   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 LLeft-associative fold of the parts of a structure that are viewed through a E, 8, 6 or D.   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   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 8,  can work over a @. When passed a 6,  requires an W.   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 c of a 6 or D or retrieve d the result  from a 8 or E.  & 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 e of a 6 or D or retrieve d the result  from a 8 or E. - 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 f if this 6 or D( has no targets in the given container. Note: nullOf on a valid 3, E or 8 should always return g   null = nullOf folded /This may be rather inefficient compared to the h 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 6 or D Note: maximumOf on a valid 3, E or 8 will always return d 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 6 or D Note: minimumOf on a valid 3, E or 8 will always return d 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 6, D, E, 3,  or 8( 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 6, D, E, 3  or 8( 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 i 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 4 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 Q 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 %This is the traversal that just doesn't return anything < traverseNothing :: Applicative f => (c -> f d) -> a -> f a This allows you to  the elements of a D in the  opposite order. Note: % is similar, but is able to accept a 6 (or 8)  and produce a 6 (or 8). This requires at least a D (or E) and can produce a  D (or E ) in turn.  A backwards 3 is the same 3". 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 j.  x^.identity = Identity x  Identity x^.from identity = x :This isomorphism can be used to wrap or unwrap a value in V  x^.konst = Const x  Const x^.from konst = x  Cloning a E) is one way to make sure you arent given  something weaker, such as a D and can be used ? as a way to pass around lenses that have to be monomorphic in f. !Note: This only accepts a proper E , because  lacks its $ (admissable) Applicative instance. Y foldMapWithIndexOf :: Monoid m => IndexedFold i a c -> (i -> c -> m) -> a -> m Y foldMapWithIndexOf :: Monoid m => IndexedTraversal i a b c d -> (i -> c -> m) -> a -> m IRight-associative fold of parts of a structure that are viewed through a E, 8, 6 or D. U foldrWithIndexOf :: IndexedFold i a c -> (i -> c -> e -> e) -> e -> a -> e U foldrWithIndexOf :: IndexedTraversal i a b c d -> (i -> c -> e -> e) -> e -> a -> e R traverseWithIndexOf :: IndexedTraversal i a b c d -> (i -> c -> f d) -> a -> f b HMap each element of a structure targeted by a lens to a monadic action, Q evaluate these actions from left to right, and collect the results, with access  its position. W mapMWithIndexOf :: Monad m => IndexedTraversal a b c d -> (i -> c -> m d) -> a -> m b /0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~klm !"$&'(*+/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~E?DCAB@GHFhilkj3254 !"$:9UTVWXmZY[rs867c{|}~degfpqno\^]_`abtuvwyxz;<=>IJKLMNOQPRS&'(*+10//0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~klm 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 n 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 o and p 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) q over a  @! with access to the current path  as a lens q over a  @! with access to the current path " as a lens, discarding the result q 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 U  Fold over a  @! with access to the current path  as a lens. rCNB: The Eq requirement on this instance is a consequence of a lens  rather than e as the representation. rsrsportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedTraverse the strongly typed t contained in u) where the type of your function matches  the desired t. @ traverseException :: (Applicative f, Exception a, Exception b) E => (a -> f b) -> SomeException -> f SomeException LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedBitwise v the target(s) of a ]-valued E or : Bitwise w the target(s) of a ]-valued E or : Modify the target(s) of a C E, : or D by computing its bitwise w with another value. Modify the target(s) of a C E, : or D by computing its bitwise v 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 E 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 x7 where the type required by your function matches that  of the contents of the x. b traverseDynamic :: (Applicative f, Typeable a, Typeable b) => (a -> f b) -> Dynamic -> f Dynamic  portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered;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)  portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered ,A lens reading and writing to the head of a  non-empty list  ghci> [1,2,3]^._head  1 ,A lens reading and writing to the tail of a  non-empty list  ghci> _tail <~ [3,4,5] $ [1,2]  [1,3,4,5] 4A lens reading and writing to the last element of a  non-empty list =A lens reading and replacing all but the a last element of a  non-empty list CObtain a version of the list with the supplied value interspersed.  ! ghci> "abcde"^.interspersed ','  "a,b,c,d,e" ' xs^.interspersed a = intersperse a xs BObtain a version of the list with the supplied value intercalated <The traversal for reading and writing to the head of a list = traverseHead :: Applicative f => (a -> f a) -> [a] -> f [a] *Traversal for editing the tail of a list. = traverseTail :: Applicative f => (a -> f a) -> [a] -> f [a] %Traverse the last element in a list. = traverseLast :: Applicative f => (a -> f a) -> [a] -> f [a] ,Traverse all but the last element of a list = traverseInit :: Applicative f => (a -> f a) -> [a] -> f [a] portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered4Traverse both parts of a tuple with matching types. This provides a D) that checks a predicate on a key before ( allowing you to traverse into a value.   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis EL can be used to read, write or delete the value associated with a key in an y.  % 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 E5 can be used to read, write or delete a member of an z  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 z by mapping  the elements to new values. Sadly, you can't create a valid D for a Set, because the number of B elements might change but you can manipulate it by reading using } and  reindexing it via setmap. / ghci> adjust members (+1) (fromList [1,2,3,4]  fromList [2,3,4,5]  Construct an z from a 8, 6, D, E or 3. - 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 EK 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 portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered A E 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 E4 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) This :% can be used to change the type of a  by mapping  the elements to new values. Sadly, you can't create a valid D for a , but you can  manipulate it by reading using } 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, 6, D, E or 3. 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 E that focuses on the root of a . A D, of the direct descendants of the root of a . 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 D. laws, when in doubt generate your names with . Has a   Extract (or modify) the  of something   Traverse free type variables  'Substitute using a map of names in for free type variables             TemplateHaskell experimentalEdward Kmett <ekmett@gmail.com> Trustworthy +This configuration describes the options we'+ll be using to make isomorphisms or lenses Flags for lens construction Only Generate valid C E lenses (Handle singleton constructors specially #Use Iso for singleton constructors @Expect a single constructor, single field newtype or data type. 6Create the class if the constructor is simple and the   rule matches 9Create the instance if the constructor is simple and the   rule matches  Die if the   fails to match RLens to access the convention for naming top level isomorphisms in our lens rules =Defaults to lowercasing the first letter of the constructor. BLens to access the convention for naming fields in our lens rules ODefaults to stripping the _ off of the field name and lowercasing the name and  rejecting the field if it doesn't start with an '_'.  wRetrieve options such as the name of the class and method to put in it to build a class around monomorphic data types. !wRetrieve options such as the name of the class and method to put in it to build a class around monomorphic data types. ")Build lenses with a custom configuration #3Build lenses with a sensible default configuration $7Make a top level isomorphism injecting _into_ the type dThe supplied name is required to be for a type with a single constructor that has a single argument %Make ' classy lenses' for a type &/Derive lenses, specifying explicit pairings of (fieldName, lensName). Example usage: < makeLensesFor [("_foo", "fooLens"), ("bar", "lbar")] ''Foo '/Derive lenses, specifying explicit pairings of (fieldName, lensName)  using a wrapper class. Example usage: K makeClassyFor "HasFoo" "foo" [("_foo", "fooLens"), ("bar", "lbar")] ''Foo    !"#$%&'   !"#$%&'   !%'$#&"   !"#$%&'&MPTCs, Rank2Types, LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered(Access 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 D 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   pack x = x^.packedBytes  unpack x = x^.from packedBytes -#Traverse the individual bytes in a   % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool .-Pack (or unpack) a list of characters into a  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  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-Infered0(Pack (or unpack) a list of bytes into a   pack x = x^.packedBytes  unpack x = x^.from packedBytes 1#Traverse the individual bytes in a   % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool 2-Pack (or unpack) a list of characters into a  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 3#Traverse the individual bytes in a  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 0123012301230123portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered4Pack (or unpack) .  pack x = x^.packed  unpack x = x^.from packed 5>Traverse the individual characters in a either strict or lazy . $ anyOf text (=='c') :: Text -> Bool 45454545portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered6Pack (or unpack) .  pack x = x^.packed  unpack x = x^.from packed 7(Traverse the individual characters in a . $ anyOf text (=='c') :: Text -> Bool 67676767portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered8Evaluate the targets of a E or D 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 9Evaluate the targets of a E or D 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 E, 6, 8, : or D to P first evaluates its argument according to a given strategy, before proceeding.  after rdeepseq traverse ; Transform a E, 6, 8, : or D to R evaluate its argument according to a given strategy in parallel with evaluating.  meanwhile rdeepseq traverse 89:;89:;89:;89:;portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered<$Evaluate the elements targeted by a E, D, 3,  8 or 6" 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) =>=>=>=>!"#!"$%%&'()**+,,-../001223445567899:;<=>?@@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~            !"#$%&'()*+,-./0123456789:789:;<;<=>?@ABC!DE!FGHIJKLMNOPQRS!TUVWXYZ!T[!\]!^_!`a!`b!"c!"d!ef!eghijhklhim!^nopq!^r!\s!et!uv!ewhkxhky!ez!u{|}~!F!`!F!"!!!!!lens-1.4 Control.LensControl.Lens.InternalControl.IsomorphicControl.IndexedControl.Lens.RepresentableControl.Exception.LensData.Bits.LensData.Complex.LensData.Dynamic.LensData.Either.LensData.List.LensData.Pair.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:~>fromviaIndex withIndex IndexableIndexedindexreindex.@composeWithIndexSimpleIndexedTraversalIndexedTraversal IndexedFold SimpleIsoIsoSimpleOverloaded OverloadedFoldGettingGetter SimpleSetterSetterFocusfocusfocus_setFocusLensLikeSimpleLensLike SimpleLensSimpleTraversalSimple TraversalLenslens%%~%%= traverseOfforOf sequenceAOfmapMOfforMOf sequenceOf transposeOf mapAccumROf mapAccumLOfscanr1Ofscanl1OfmappedsetsadjustmapOfset%~^~<~+~*~-~//~||~&&~<>~toviewviews^$^._1_2 elementOfelementresultAtwhisperqueryqueriesuseuses^=%=+=-=*=//=&&=||=<>=foldsfoldingfoldedrepeated replicatedcycledunfoldediteratedfilteredreversed takingWhile droppingWhile foldMapOffoldOffoldrOffoldlOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOfheadOflastOfnullOf maximumOf minimumOf maximumByOf minimumByOffindOffoldr1Offoldl1OffoldrOf'foldlOf'foldrMOffoldlMOftraverseNothing backwardsmerged bothLensesisosisoidentitykonstclonefoldMapWithIndexOffoldrWithIndexOftraverseWithIndexOfmapMWithIndexOfKeyturn RepresentablerepRepfmapReppureRepapRepbindRep distributeRepkeys tabulated mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithReptraverseException|~&~&=|=bitAt traverseBitsreal imaginarypolarizetraverseComplextraverseDynamic traverseLeft traverseRight_head_tail_last_init interspersed intercalated traverseHead traverseTail traverseLast traverseInitbothvalueat traverseAt traverseAtMin traverseAtMaxcontainsmemberssetOfviewLviewR traverseTo traverseFrom traverseSlicerootchildren SubstType substType HasTypeVars typeVarsExHasNamenametypeVars substTypeVars LensRulesLensFlag ClassRequiredCreateInstance CreateClassSingletonRequiredHandleSingletons SingletonIsoSingletonAndField SimpleLenses simpleLenseshandleSingletons singletonIsosingletonRequired createClasscreateInstance classRequiredlensIso lensField lensClass lensFlagsmakeLensesWith makeLensesmakeIso makeClassy makeLensesFor makeClassyForixamappedixmapped traverseArray packedBytesbytes packedCharscharspackedtextevalOfparOfafter meanwhileseqOfgenericgeneric1 Control.MonadmapM_GHC.BaseFunctor$fApplicativeElementOf$fFunctorElementOf$fFunctorElementOfResult $fMonoidMax $fMonoidMin$fMonoidAction$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusingControl.CategoryCategory$fIsomorphicIsomorphism$fCategoryIsomorphism$fIsomorphic(->)$fIndexediIndex$fIndexedi(->)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