)l      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~TemplateHaskell experimentalEdward Kmett <ekmett@gmail.com> Trustworthy*Derive lenses for the record selectors in ( a single-constructor data declaration, 6 or for the record selector in a newtype declaration. 7 Lenses will only be generated for record fields which " are prefixed with an underscore. Example usage:  makeLenses ''Foo /Derive lenses, specifying explicit pairings of (fieldName, lensName). Example usage: < makeLensesFor [("_foo", "fooLens"), ("bar", "lbar")] ''Foo 4Derive lenses with the provided name transformation ! and filtering function. Produce  Just lensName to generate a lens  of the resultant name, or Nothing to not generate a lens  for the input record name. Example usage: , makeLensesBy (\n -> Just (n ++ "L")) ''Foo the name transformer  Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered Used for  maximumOf  Used for  minimumOf Used internally by  traverseOf_,  and the like. Applicative composition of  State Int with a , used  by  elementOf,  elementsOf, traverseElement, traverseElementsOf 0The indexed store can be used to characterize a  LensFamily  and is used by clone Used by Focus Obtain the minimum Obtain the maximum        Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered~=Types that support traversal of the value of the maximal key This is separate from  because a min-heap < or max-heap may be able to support one, but not the other. 'Traverse the value for the maximal key =Types that support traversal of the value of the minimal key This is separate from  because a min-heap < or max-heap may be able to support one, but not the other. 'Traverse the value for the minimal key  Provides ad hoc overloading for  (Traverse the individual characters in a  ; anyOf traverseText (=='c') :: TraverseText b => b -> Bool  Provides ad hoc overloading for  #Traverse the individual bytes in a  H anyOf traverseByteString (==0x80) :: TraverseByteString b => b -> Bool A  can be used directly as a # or a  (but not as a () and provides V the ability to both read and update multiple fields, subject to some relatively weak  laws. These are also known as  MultiLens5 families, 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. A I describes how to retrieve multiple values in a way that can be composed % with other lens-like constructions. A  a b c dC provides a structure with operations very similar to those of the   typeclass, see Y and the other  combinators. !By convention, if there exists a foo method that expects a  (f c), then there should be a  fooOf method that takes a  a b c d and a value of type a. A % is a legal  that just ignores the supplied   Unlike a  a  is read-only. Since a  cannot be used to write back 3 there are no lens laws that can be applied to it. In practice the b and dA are left dangling and unused, and as such is no real point in a ' . = type Fold a b c d = forall m. Monoid m => Getting m a b c d 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 ' ( or 'Simple Traversal'. lThis is commonly used to lift actions in a simpler state monad into a state monad with a larger state type. When applied to a 'Simple M over multiple values, the actions for each target are executed sequentially + and the results are aggregated monoidally  and a monoidal summary  of the result is given. N focus :: Monad m => Simple Lens a b -> st b m c -> st a m c N focus :: (Monad m, Monoid c) => Simple Traversal a b -> st b m c -> st a m c "Like !4, but discarding any accumulated results as you go. P focus_ :: Monad m => Simple Lens a b -> st b m c -> st a m () P focus_ :: (Monad m, Monoid c) => Simple Traversal a b -> st b m c -> st a m () # The only (-like law that applies to a # l is that  ! set l c (set l b a) = set l c a You can't , a #1 in general, so the other two laws do not apply. You can compose a # with a ( or a  using (.) from the Prelude ! and the result is always only a # and nothing more. 1 type Setter a b c d = LensLike Identity a b c d $Most %- combinators are able to be used with both a % or a  in S limited situations, to do so, they need to be monomorphic in what we are going to  extract with . If a function accepts a Getting r a b c d , then when r is a Monoid, you can  pass a  (or &), otherwise you can only pass this a % or (. 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 ( a % is read-only. Since a % cannot be used to write back 3 there are no lens laws that can be applied to it.  Moreover, a % can be used directly as a , since it just ignores the . In practice the b and d? are left dangling and unused, and as such is no real point in  using a ' %. ;type Getter a b c d = forall z. LensLike (Const z) a b c d &Many combinators that accept a ( can also accept a  in limited situations. 'They do so by specializing the type of " that they require of the caller. If a function accepts a & f a b c d for some  f, then they may be passed a (.  Further, if f is an , they may also be passed a . 'A ' (, ' #, or '  can be used instead of a ( # or   whenever the type variables don't change upon setting a value.  ( imaginary :: Simple Lens (Complex a) a ' imaginary f (e :+ i) = (e :+) <$> f i ( traverseHead :: Simple Traversal [a] a (A (+ is actually a lens family as described in  /http://comonad.com/reader/2012/mirrored-lenses/. 2With great power comes great responsibility and a ( is subject to the lens laws:   view l (set l b a) = b  set l (view l a) a = a ! set l c (set l b a) = set l c a =These laws are strong enough that the 4 type parameters of a (. 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 ( can be used directly as a %, #,  or . 0 identity :: Lens (Identity a) (Identity b) a b , identity f (Identity a) = Identity <$> f a )Build a ( from a getter and a setter. J lens :: Functor f => (a -> c) -> (d -> a -> b) -> (c -> f d) -> a -> f b *Built a ( from an isomorphism family D iso :: Functor f => (a -> c) -> (d -> b) -> (c -> f d) -> a -> f b +Build a %  to f . to g = to (g . f) ,View the value pointed to by a % or ( or the result of folding over  all the results of a  or # that points at a monoidal values. It may be useful to think of ,. as having these more restrictive signatures:  1 view :: Lens a b c d -> a -> c 1 view :: Getter a b c d -> a -> c 1 view :: Monoid m => Fold a b m d -> a -> m 1 view :: Monoid m => Traversal a b m d -> a -> m 8 view :: ((c -> Const c d) -> a -> Const c b) -> a -> c -View the value of a %, (# or the result of folding over the $ result of mapping the targets of a  or . It may be useful to think of -. as having these more restrictive signatures:  > views :: Getter a b c d -> (c -> d) -> a -> d > views :: Lens a b c d -> (c -> d) -> a -> d > views :: Monoid m => Fold a b c d -> (c -> m) -> a -> m > views :: Monoid m => Traversal a b c d -> (c -> m) -> a -> m E views :: ((c -> Const m d) -> a -> Const m b) -> (c -> m) -> a -> m .View the value pointed to by a % or ( or the result of folding over  all the results of a  or # that points at a monoidal values. This is the same operation as ,, only infix.  1 (^$) :: Lens a b c d -> a -> c 1 (^$) :: Getter a b c d -> a -> c 1 (^$) :: Monoid m => Fold a b m d -> a -> m 1 (^$) :: Monoid m => Traversal a b m d -> a -> m 8 (^$) :: ((c -> Const c d) -> a -> Const c b) -> a -> c /View the value pointed to by a % or ( or the result of folding over  all the results of a  or # that points at a monoidal values. This is the same operation as , with the arguments flipped. HThe fixity and semantics are such that subsequent field accesses can be  performed with (Prelude..)  , ghci> ((0, 1 :+ 2), 3)^._1._2.to magnitude  2.23606797749979  1 (^.) :: a -> Lens a b c d -> c 1 (^.) :: a -> Getter a b c d -> c 1 (^.) :: Monoid m => a -> Fold a b m d -> m 1 (^.) :: Monoid m => a -> Traversal a b m d -> m 8 (^.) :: a -> ((c -> Const c d) -> a -> Const c b) -> c 0FThis setter can be used to map over all of the values in a container. 1Build a Setter  sets . adjust = id  adjust . sets = id 2Modify the target of a ( or all the targets of a # or   with a function.   fmap = adjust traverse -Two useful free theorems hold for this type:  sets . adjust = id  adjust . sets = id 3Replace the target of a ( or all of the targets of a #  or  with a constant value.  (<$) = set traverse 4Modifies the target of a ( or all of the targets of a # or   with a user supplied function. This is an infix version of 2  fmap f = traverse =%= f 5Replace the target of a ( or all of the targets of a #  or  with a constant value. This is an infix version of 3  f <$ a = traverse =~= f $ a 60Increment the target(s) of a numerically valued (, Setter' or   ghci> _1 =+= 1 $ (1,2)  (2,2) 7/Multiply the target(s) of a numerically valued (, # or   ghci> _2 =*= 4 $ (1,2)  (1,8) 80Decrement the target(s) of a numerically valued (, # or   ghci> _1 =-= 2 $ (1,2)  (-1,2) 9-Divide the target(s) of a numerically valued (, # or  : Logically  the target(s) of a -valued ( or # ; Logically  the target(s) of a -valued ( or # <Bitwise  the target(s) of a -valued ( or # =Bitwise  the target(s) of a -valued ( or # >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) @This (K can be used to read, write or delete the value associated with a key in a .  6 ghci> Map.fromList [("hello",12)] ^. valueAt "hello"  Just 12 M valueAt :: Ord k => k -> (Maybe v -> f (Maybe v)) -> Map k v -> f (Map k v) AThis (5 can be used to read, write or delete a member of an .  6 ghci> IntMap.fromList [(1,"hello")] ^. valueAtInt 1  Just "hello"  B ghci> valueAtInt 2 =+= "goodbye" $ IntMap.fromList [(1,"hello")] & fromList [(1,"hello"),(2,"goodbye")] K valueAtInt :: Int -> (Maybe v -> f (Maybe v)) -> IntMap v -> f (IntMap v) BThis (4 can be used to read, write or delete a member of a   5 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) CThis (5 can be used to read, write or delete a member of an   ; ghci> containsInt 3 =+= False $ IntSet.fromList [1,2,3,4]  fromList [1,2,4] > containsInt :: Int -> (Bool -> f Bool) -> IntSet -> f IntSet DCThis lens can be used to access the contents of the Identity monad EFThis lens can be used to access the value of the nth bit in a number. bitsAt n is only a legal ( into b if 0 <= n < bitSize (undefined :: b) FHThis lens can be used to change the result of a function but only where $ the arguments match the key given. G)Access the real part of a complex number ? real :: Functor f => (a -> f a) -> Complex a -> f (Complex a) H.Access the imaginary part of a complex number D imaginary :: Functor f => (a -> f a) -> Complex a -> f (Complex a) IThis 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 convenient lens. Jpolarize :: Functor f => ((a,a) -> f (a,a)) -> Complex a -> f (Complex a) JAccess the target of a ( or %# in the current state, or access a  summary of a  or " that points to a monoidal value.  B access :: MonadState a m => Getter a b c d -> m c B access :: MonadState a m => Lens a b c d -> m c B access :: (MonadState a m, Monoid c) => Fold a b c d -> m c B access :: (MonadState a m, Monoid c) => Traversal a b c d -> m c I access :: MonadState a m => ((c -> Const c d) -> a -> Const c b) -> m c KModify the target of a (: in the current state returning some extra information of c or  modify all targets of a < in the current state, extracting extra information of type c / and return a monoidal summary of the changes. It may be useful to think of '(%%=)'=, instead, as having either of the following more restricted  type signatures:  T (%%=) :: MonadState a m => Simple Lens a b -> (b -> (c, b) -> m c T (%%=) :: (MonadState a m, Monoid c) => Simple Traversal a b -> (b -> (c, b) -> m c Q (%%=) :: MonadState a m => ((b -> (c,b)) -> a -> (c,a)) -> (b -> (c, b)) -> m c LReplace the target of a ( or all of the targets of a # or  in our monadic 2 state with a new value, irrespective of the old. MMap over the target of a ( or all of the targets of a # or ' Traversal in our monadic state. NModify the target(s) of a ' (, # or  by adding a value OModify the target(s) of a ' (, # or  by subtracting a value PModify the target(s) of a ' (, # or  by multiplying by value QModify the target(s) of a ' (, # or  by dividing by a value RModify the target(s) of a ' (, # or  by taking their logical  with a value SModify the target(s) of a ' (, # or  by taking their logical  with a value TModify the target(s) of a ' (, # or  by computing its bitwise  with another value. UModify the target(s) of a ' (, # or  by computing its bitwise  with another value. V Obtain a  from any  W Obtain a  by filtering a (, 'Getter,  or . X Obtain a + by reversing the order of traversal for a (, %,  or . Of course, reversing a  or % has no effect. Y  foldMap = foldMapOf folded   foldMapOf = views B foldMapOf :: Getter a b c d -> (c -> m) -> a -> m B foldMapOf :: Lens a b c d -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Fold a b c d -> (c -> m) -> a -> m B foldMapOf :: Monoid m => Traversal a b c d -> (c -> m) -> a -> m Z  fold = foldOf folded   foldOf = view 3 foldOf :: Getter a b m d -> a -> m 3 foldOf :: Lens a b m d -> a -> m 3 foldOf :: Monoid m => Fold a b m d -> a -> m 3 foldOf :: Monoid m => Traversal a b m d -> a -> m [IRight-associative fold of parts of a structure that are viewed through a (, %,  or .   foldr = foldrOf folded > foldrOf :: Getter a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Lens a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Fold a b c d -> (c -> e -> e) -> e -> a -> e > foldrOf :: Traversal a b c d -> (c -> e -> e) -> e -> a -> e \LLeft-associative fold of the parts of a structure that are viewed through a (, %,  or .   foldl = foldlOf folded > foldlOf :: Getter a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Lens a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Fold a b c d -> (e -> c -> e) -> e -> a -> e > foldlOf :: Traversal a b c d -> (e -> c -> e) -> e -> a -> e ] A variant of [N that has no base case and thus may only be applied to lenses and structures A such that the lens views at least one element of the structure.  . foldr1Of l f = Prelude.foldr1 f . toListOf l   foldr1 = foldr1Of folded : foldr1Of :: Getter a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Lens a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Fold a b c d -> (c -> c -> c) -> a -> c : foldr1Of :: Traversal a b c d -> (c -> c -> c) -> a -> c ^ A variant of \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 b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Lens a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Fold a b c d -> (c -> c -> c) -> a -> c : foldl1Of :: Traversal a b c d -> (c -> c -> c) -> a -> c _6Strictly fold right over the elements of a structure.   foldr' = foldrOf' folded ? foldrOf' :: Getter a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Lens a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Fold a b c d -> (c -> e -> e) -> e -> a -> e ? foldrOf' :: Traversal a b c d -> (c -> e -> e) -> e -> a -> e `NFold over the elements of a structure, associating to the left, but strictly.   foldl' = foldlOf' folded ? foldlOf' :: Getter a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Lens a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Fold a b c d -> (e -> c -> e) -> e -> a -> e ? foldlOf' :: Traversal a b c d -> (e -> c -> e) -> e -> a -> e abMonadic fold over the elements of a structure, associating to the right, i.e. from right to left.   foldrM = foldrMOf folded N foldrMOf :: Monad m => Getter a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Lens a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Fold a b c d -> (c -> e -> m e) -> e -> a -> m e N foldrMOf :: Monad m => Traversal a b c d -> (c -> e -> m e) -> e -> a -> m e baMonadic fold over the elements of a structure, associating to the left, i.e. from left to right.   foldlM = foldlMOf folded N foldlMOf :: Monad m => Getter a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Lens a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Fold a b c d -> (e -> c -> m e) -> e -> a -> m e N foldlMOf :: Monad m => Traversal a b c d -> (e -> c -> m e) -> e -> a -> m e c  toList = toListOf folded + toListOf :: Getter a b c d -> a -> [c] + toListOf :: Lens a b c d -> a -> [c] + toListOf :: Fold a b c d -> a -> [c] + toListOf :: Traversal a b c d -> a -> [c] d  and = andOf folded + andOf :: Getter a b Bool d -> a -> Bool + andOf :: Lens a b Bool d -> a -> Bool + andOf :: Fold a b Bool d -> a -> Bool + andOf :: Traversl a b Bool d -> a -> Bool e  or = orOf folded + orOf :: Getter a b Bool d -> a -> Bool + orOf :: Lens a b Bool d -> a -> Bool + orOf :: Fold a b Bool d -> a -> Bool + orOf :: Traversal a b Bool d -> a -> Bool f  any = anyOf folded 8 anyOf :: Getter a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Fold a b c d -> (c -> Bool) -> a -> Bool 8 anyOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool g  all = allOf folded 8 allOf :: Getter a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Lens a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Fold a b c d -> (c -> Bool) -> a -> Bool 8 allOf :: Traversal a b c d -> (c -> Bool) -> a -> Bool h  product = productOf folded 3 productOf :: Getter a b c d -> a -> c 3 productOf :: Lens a b c d -> a -> c 3 productOf :: Num c => Fold a b c d -> a -> c 3 productOf :: Num c => Traversal a b c d -> a -> c i  sum = sumOf folded   sumOf _1 :: (a, b) -> a ; sumOf (folded._1) :: (Foldable f, Num a) => f (a, b) -> a / sumOf :: Getter a b c d -> a -> c / sumOf :: Lens a b c d -> a -> c / sumOf :: Num c => Fold a b c d -> a -> c / sumOf :: Num c => Traversal a b c d -> a -> c jWhen passed a %, j can work over a . When passed a , j requires an .   traverse_ = traverseOf_ folded  > traverseOf_ _2 :: Functor f => (c -> f e) -> (c1, c) -> f () O traverseOf_ traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f () bThe rather specific signature of traverseOf_ allows it to be used as if the signature was either: N traverseOf_ :: Functor f => Getter a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Lens a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Fold a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Traversal a b c d -> (c -> f e) -> a -> f () k  for_ = forOf_ folded I forOf_ :: Functor f => Getter a b c d -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Lens a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Fold a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Traversal a b c d -> a -> (c -> f e) -> f () l " sequenceA_ = sequenceAOf_ folded F sequenceAOf_ :: Functor f => Getter a b (f ()) d -> a -> f () F sequenceAOf_ :: Functor f => Lens a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Fold a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Traversal a b (f ()) d -> a -> f () m  mapM_ = mapMOf_ folded D mapMOf_ :: Monad m => Getter a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Lens a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Fold a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Traversal a b c d -> (c -> m e) -> a -> m () n  forM_ = forMOf_ folded D forMOf_ :: Monad m => Getter a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Lens a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Fold a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Traversal a b c d -> a -> (c -> m e) -> m () o  sequence_ = sequenceOf_ folded > sequenceOf_ :: Monad m => Getter a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Lens a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Fold a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Traversal a b (m b) d -> a -> m () p1The sum of a collection of actions, generalizing u.   asum = asumOf folded : asumOf :: Alternative f => Getter a b c d -> a -> f c : asumOf :: Alternative f => Lens a b c d -> a -> f c : asumOf :: Alternative f => Fold a b c d -> a -> f c : asumOf :: Alternative f => Traversal a b c d -> a -> f c q1The sum of a collection of actions, generalizing u.   msum = msumOf folded 8 msumOf :: MonadPlus m => Getter a b c d -> a -> m c 8 msumOf :: MonadPlus m => Lens a b c d -> a -> m c 8 msumOf :: MonadPlus m => Fold a b c d -> a -> m c 8 msumOf :: MonadPlus m => Traversal a b c d -> a -> m c r  elem = elemOf folded 7 elemOf :: Eq c => Getter a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Lens a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Fold a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Traversal a b c d -> c -> a -> Bool s  notElem = notElemOf folded : notElemOf :: Eq c => Getter a b c d -> c -> a -> Bool : notElemOf :: Eq c => Fold a b c d -> c -> a -> Bool : notElemOf :: Eq c => Lens a b c d -> c -> a -> Bool : notElemOf :: Eq c => Traversal a b c d -> c -> a -> Bool t  concatMap = concatMapOf folded < concatMapOf :: Getter a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Lens a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Fold a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Traversal a b c d -> (c -> [e]) -> a -> [e] u  concat = concatOf folded * concatOf :: Getter a b [e] d -> a -> [e] ( concatOf :: Lens a b [e] d -> a -> [e] ( concatOf :: Fold a b [e] d -> a -> [e] # concatOf :: a b [e] d -> a -> [e] v;Note: this can be rather inefficient for large containers.   length = lengthOf folded   lengthOf _1 :: (a, b) -> Int  lengthOf _1 = 1 : lengthOf (folded.folded) :: Foldable f => f (g a) -> Int + lengthOf :: Getter a b c d -> a -> Int + lengthOf :: Lens a b c d -> a -> Int + lengthOf :: Fold a b c d -> a -> Int + lengthOf :: Traversal a b c d -> a -> Int wReturns  if this  or ( has no targets in the given container. Note: nullOf on a valid ( or % will always return    null = nullOf folded /This may be rather inefficient compared to the  check of many containers.   nullOf _1 :: (a, b) -> Int  nullOf _1 = False ? nullOf (folded._1.folded) :: Foldable f => f (g a, b) -> Bool * nullOf :: Getter a b c d -> a -> Bool * nullOf :: Lens a b c d -> a -> Bool * nullOf :: Fold a b c d -> a -> Bool * nullOf :: Traversal a b c d -> a -> Bool x2Obtain the maximum element (if any) targeted by a  or  Note: maximumOf on a valid ( or % will always return  a value.  8 maximum = fromMaybe (error "empty") . maximumOf folded 9 maximumOf :: Getter a b c d -> a -> Maybe c 9 maximumOf :: Lens a b c d -> a -> Maybe c 9 maximumOf :: Ord c => Fold a b c d -> a -> Maybe c 9 maximumOf :: Ord c => Traversal a b c d -> a -> Maybe c y2Obtain the minimum element (if any) targeted by a  or  Note: minimumOf on a valid ( or % will always return  a value.  8 minimum = fromMaybe (error "empty") . minimumOf folded 9 minimumOf :: Getter a b c d -> a -> Maybe c 9 minimumOf :: Lens a b c d -> a -> Maybe c 9 minimumOf :: Ord c => Fold a b c d -> a -> Maybe c 9 minimumOf :: Ord c => Traversal a b c d -> a -> Maybe c z2Obtain the maximum element (if any) targeted by a , , (  or %( according to a user supplied ordering.  D maximumBy cmp = fromMaybe (error "empty") . maximumByOf folded cmp J maximumByOf :: Getter a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Lens a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Fold a b c d -> (c -> c -> Ordering) -> a -> Maybe c J maximumByOf :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c {2Obtain the minimum element (if any) targeted by a , , (  or %( according to a user supplied ordering.  D minimumBy cmp = fromMaybe (error "empty") . minimumByOf folded cmp J minimumByOf :: Getter a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Lens a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Fold a b c d -> (c -> c -> Ordering) -> a -> Maybe c J minimumByOf :: Traversal a b c d -> (c -> c -> Ordering) -> a -> Maybe c |The |@ function takes a lens, a predicate and a structure and returns B the leftmost element of the structure matching the predicate, or   if there is no such element. }CProvided for completeness, but this is just the identity function.  traverseOf = id  traverse = traverseOf traverse ~  mapM = mapMOf traverse B mapMOf :: Monad m => 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  " sequenceA = sequenceAOf traverse G sequenceAOf :: Applicative f => Lens a b (f c) (f c) -> a -> f b G sequenceAOf :: Applicative f => Traversal a b (f c) (f c) -> a -> f b   sequence = sequenceOf traverse @ sequenceOf :: Monad m => Lens a b (m c) (m c) -> a -> m b @ sequenceOf :: Monad m => Traversal a b (m c) (m c) -> a -> m b  Yields a  of the nth element of another  % traverseHead = elementOf traverse 0 A  of the elements in another  where their positions in that  satisfy a predicate ) traverseTail = elementsOf traverse (>0)  F transpose = transposeOf traverse -- modulo the ragged arrays support ( transposeOf _2 :: (b, [a]) -> [(b, a)] BThis is the traversal that never succeeds at returning any values < traverseNothing :: Applicative f => (c -> f d) -> a -> f a = traverseHead :: Applicative f => (a -> f a) -> [a] -> f [a] *Traversal for editing the tail of a list. A traverseTail :: Applicative f => ([a] -> f [a]) -> [a] -> f [a] %Traverse the last element in a list.  # traverseLast = traverseValueAtMax = traverseLast :: Applicative f => (a -> f a) -> [a] -> f [a] ,Traverse all but the last element of a list A traverseInit :: Applicative f => ([a] -> f [a]) -> [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:  N traverseRight :: Applicative f => (a -> f b) -> Either c a -> f (Either c a)  traverseRight = traverse Unfortunately the instance for 'Traversable (Either c)' is still missing from  base, so this can' t just be  +Traverse the value at a given key in a Map X traverseValueAt :: (Applicative f, Ord k) => k -> (v -> f v) -> Map k v -> f (Map k v) * traverseValueAt k = valueAt k . traverse /Traverse the value at a given key in an IntMap V traverseValueAtInt :: Applicative f => Int -> (v -> f v) -> IntMap v -> f (IntMap v) 0 traverseValueAtInt k = valueAtInt k . traverse 6Traverse a single element in a traversable container. Z traverseElement :: (Applicative f, Traversable t) => Int -> (a -> f a) -> t a -> f (t a) WTraverse elements where a predicate holds on their position in a traversable container d traverseElements :: Applicative f, Traversable t) => (Int -> Bool) -> (a -> f a) -> t a -> f (t a) (Traverse the typed value contained in a 7 where the type required by your function matches that  of the contents of the . b traverseDynamic :: (Applicative f, Typeable a, Typeable b) => (a -> f b) -> Dynamic -> f Dynamic Traverse the strongly typed  contained in ) where the type of your function matches  the desired . r traverseException :: (Applicative f, Exception a, Exception b) => (a -> f b) -> SomeException -> f SomeException *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...  Cloning a () is one way to make sure you arent given  something weaker, such as a  and can be used ? as a way to pass around lenses that have to be monomorphic in f. !Note: This only accepts a proper ( , because  lacks its $ (admissable) Applicative instance. 'We can focus Reader environments, too!  !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~} !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~}(&')*%$+,-/.#1023456879:;<=JMLNOPQSRUTK !">?@AEBCDFGHIVWXYZ[\_`]^abcfgdehijklmnopqtursvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ RankNTypes provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedGSometimes you need to store a path lens into a container, but at least F at this time, impredicative polymorphism in GHC is somewhat lacking. FThis type provides a way to, say, store a list of polymorphic lenses. Representable Functors. A  f is  if it is isomorphic to (x -> a) > for some x. All such functors can be represented by choosing x to be ? the set of lenses that are polymorphic in the contents of the ,  that is to say  x = Rep f is a valid choice of x for every   . @Note: Some sources refer to covariant representable functors as ) corepresentable functors, and leave the " representable" name to 1 contravariant functors (those are isomorphic to (a -> x) for some x). LAs the covariant case is vastly more common, and both are often referred to = as representable functors, we choose to call these functors   here. The representation of a   as Lenses # is a valid default definition for  for a representable  functor.  $ fmapRep f m = rep $ \i -> f (m^.i) "Usage for a representable functor Foo:  instance Functor Foo where  fmap = fmapRep # is a valid default definition for  and  for a  representable functor.   pureRep = rep . const "Usage for a representable functor Foo:   instance Applicative Foo where  pure = pureRep  (<*>) = apRep  instance Monad Foo where  return = pureRep  (>>=) = bindRep # is a valid default definition for '( *)' for a representable  functor.  ) apRep mf ma = rep $ \i -> mf^.i $ ma^.i "Usage for a representable functor Foo:  instance Applicative Foo where  pure = pureRep  (<*>) = apRep + is a valid default default definition for '(>>=)' for a  representable functor.  & bindRep m f = rep $ \i -> f(m^.i)^.i "Usage for a representable functor Foo:  instance Monad ... where  return = pureRep  (>>=) = bindRep A default definition for  for a    . distributeRep wf = rep $ \i -> fmap (^.i) wf Typical Usage: ! instance Distributive ... where  distribute = distributeRep A  . has a fixed shape. This fills each position  in it with a   Map over a  " with access to the lens for the  current position ) mapWithKey f m = rep $ \i -> f i (m^.i)  Traverse a  ! with access to the current path  Traverse a  ! with access to the current path " as a lens, discarding the result  Traverse a  ! with access to the current path ( and a lens (and the arguments flipped)  over a  ! with access to the current path  as a lens  over a  ! with access to the current path " as a lens, discarding the result  over a  ! with access to the current path ( as a lens (with the arguments flipped)  Fold over a  ! with access to the current path  as a lens, yielding a   Fold over a  ! with access to the current path  as a lens. CNB: The Eq requirement on this instance is a consequence of a lens  rather than e as the representation.         !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~lens-0.9Control.Lens.THControl.Lens.Internal Control.LensControl.Lens.RepresentableData.Distributive distribute makeLenses makeLensesFor makeLensesByMaxNoMaxMinNoMin Traversed getTraversed AppliedStaterunAppliedState IndexedStoreFocusing unfocusinggetMingetMaxTraverseValueAtMaxtraverseValueAtMaxTraverseValueAtMintraverseValueAtMin TraverseText traverseTextTraverseByteStringtraverseByteString TraversalFoldFocusfocusfocus_SetterGettingGetterLensLikeSimpleLenslensisotoviewviews^$^.mappedsetsadjustset=%==~==+==*==-==/==||==&&==|==&=_1_2valueAt valueAtIntcontains containsIntidentitybitAtresultAtreal imaginarypolarizeaccess%%=~=%=+=-=*=//=&&=||=&=|=foldedfilteredreversed foldMapOffoldOffoldrOffoldlOffoldr1Offoldl1OffoldrOf'foldlOf'foldrMOffoldlMOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOfnullOf maximumOf minimumOf maximumByOf minimumByOffindOf traverseOfmapMOf sequenceAOf sequenceOf elementOf elementsOf transposeOftraverseNothing traverseHead traverseTail traverseLast traverseInit traverseLeft traverseRighttraverseValueAttraverseValueAtInttraverseElementtraverseElementstraverseDynamictraverseException traverseBitscloneKeyturn RepresentablerepRepfmapReppureRepapRepbindRep distributeRepkeys mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithRepbase Control.MonadmapM_GHC.BaseFunctor $fMonoidMax $fMonoidMin$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusing text-0.11.2.2Data.Text.InternalTextbytestring-0.9.2.1Data.ByteString.Lazy.Internal ByteString Data.FoldableFoldable Data.MonoidMonoidControl.ApplicativeConst Applicativeghc-prim GHC.Classes|| GHC.TypesBool&& Data.Bits.|..&.containers-0.4.2.1Data.MapMap Data.IntMapIntMapData.SetSet Data.IntSetIntSetTrueFalseData.ByteStringnull Data.MaybeJustNothingData.Traversabletraverse Data.DynamicDynamic GHC.Exception Exception SomeException$fFocusReaderT$fTraverseValueAtMaxSeq$fTraverseValueAtMax[]$fTraverseValueAtMaxIntMap$fTraverseValueAtMaxMap$fTraverseValueAtMinTree$fTraverseValueAtMinSeq$fTraverseValueAtMin[]$fTraverseValueAtMinIntMap$fTraverseValueAtMinMap$fTraverseTextText$fTraverseTextText0$fTraverseByteStringByteString$fTraverseByteStringByteString0 $fFocusStateT$fFocusStateT0fmappurereturnmapM$fRepresentable(->)$fRepresentableIdentity