!"#$%&'()*+,-./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>SafeUsed 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        Rank2Types provisionalEdward Kmett <ekmett@gmail.com>Safee=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 bytes in a ByteString 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 I 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  . 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. = 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 0, discarding any accumulated results as you go.  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. 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  . 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 !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 "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 #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 $FThis setter can be used to map over all of the values in a container. %Build a Setter  sets . adjust = id  adjust . sets = id &Modify 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 H adjust :: ((c -> Identity d) -> a -> Identity b) -> (c -> d) -> a -> b 'Replace the target of a  or all of the targets of a   or  with a constant value.   (<$) = set traverse > set :: ((c -> Identity d) -> a -> Identity b) -> d -> a -> b (Modifies the target of a  or all of the targets of a  or   with a user supplied function. This is an infix version of &   fmap f = traverse =%= f G (=%=) :: ((c -> Identity d) -> a -> Identity b) -> (c -> d) -> a -> b )Replace the target of a  or all of the targets of a   or  with a constant value. This is an infix version of '   f <$ a = traverse =~= f $ a @ (=~=) :: ((c -> Identity d) -> a -> Identity b) -> d -> a -> b *0Increment the target(s) of a numerically valued , Setter' or    ghci> _1 =+= 1 $ (1,2)  (2,2) I (=+=) :: Num c => ((c -> Identity c) -> a -> Identity b) -> c -> a -> b +/Multiply the target(s) of a numerically valued ,  or    ghci> _2 =*= 4 $ (1,2)  (1,8) I (=*=) :: Num c => ((c -> Identity c) -> a -> Identity b) -> c -> a -> b ,0Decrement the target(s) of a numerically valued ,  or    ghci> _1 =-= 2 $ (1,2)  (-1,2) @ (=-=) :: ((c -> Identity c) -> a -> Identity b) -> c -> a -> b --Divide the target(s) of a numerically valued ,  or  P (=/=) :: Fractional c => ((c -> Identity c) -> a -> Identity b) -> c -> a -> b . Logically  the target(s) of a -valued  or  I (=||=):: ((Bool -> Identity Bool) -> a -> Identity b) -> Bool -> a -> b / Logically  the target(s) of a -valued  or  (=&&E=) :: ((Bool -> Identity Bool) -> a -> Identity b) -> Bool -> a -> b 0Bitwise  the target(s) of a -valued  or  L (=|=):: Bits c => ((c -> Identity c) -> a -> Identity b) -> Bool -> a -> b 1Bitwise  the target(s) of a -valued  or  J (=&=) :: Bits c => ((b -> Identity b) -> a -> Identity a) -> c -> a -> b 2JThis 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) 3As 2&, 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) 4This 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) 5This 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) 6This 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) 7This 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 8CThis lens can be used to access the contents of the Identity monad 9FThis 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) :HThis lens can be used to change the result of a function but only where $ the arguments match the key given. ;Access 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 <Modify 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: C (%%=) :: 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 =Replace 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. >Map over the target of a  or all of the targets of a  or ' Traversal in our monadic state. ?Modify the target(s) of a  ,  or  by adding a value @Modify the target(s) of a  ,  or  by subtracting a value AModify the target(s) of a  ,  or  by multiplying by value BModify the target(s) of a  ,  or  by dividing by a value CModify the target(s) of a  ,  or  by taking their logical  with a value DModify the target(s) of a  ,  or  by taking their logical  with a value EModify the target(s) of a  ,  or  by computing its bitwise  with another value. FModify the target(s) of a  ,  or  by computing its bitwise  with another value. GBuilding a Fold H Obtain a  from any  I  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 J  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 K  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 L  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] M  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 N  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 O  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 P  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 Q  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 R  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 SWhen passed a , S can work over a . When passed a , S 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 () T  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 () U " 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 () V  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 () W  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 () X  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 () Y1The sum of a collection of actions, generalizing ^.   asum = asumOf folded : asumOf :: Alternative f => Getter a b c d -> a -> f c : asumOf :: Alternative f => Lens a b c d -> a -> f c : asumOf :: Alternative f => Fold a b c d -> a -> f c : asumOf :: Alternative f => Traversal a b c d -> a -> f c Z1The sum of a collection of actions, generalizing ^.   msum = msumOf folded 8 msumOf :: MonadPlus m => Getter a b c d -> a -> m c 8 msumOf :: MonadPlus m => Lens a b c d -> a -> m c 8 msumOf :: MonadPlus m => Fold a b c d -> a -> m c 8 msumOf :: MonadPlus m => Traversal a b c d -> a -> m c [  elem = elemOf folded 7 elemOf :: Eq c => Getter a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Lens a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Fold a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Traversal a b c d -> c -> a -> Bool \  notElem = notElemOf folded : notElemOf :: Eq c => Getter a b c d -> c -> a -> Bool : notElemOf :: Eq c => Fold a b c d -> c -> a -> Bool : notElemOf :: Eq c => Lens a b c d -> c -> a -> Bool : notElemOf :: Eq c => Traversal a b c d -> c -> a -> Bool ]  concatMap = concatMapOf folded = concatMapOf :: Getter a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Lens a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Fold a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Traversal a b c d -> (c -> [e]) -> a -> [e] ^  concat = concatOf folded * concatOf :: Getter a b [e] d -> a -> [e] ( concatOf :: Lens a b [e] d -> a -> [e] ( concatOf :: Fold a b [e] d -> a -> [e] # concatOf :: a b [e] d -> a -> [e] _  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 a  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 bA  of the nth element of another  % traverseHead = elementOf traverse 0 cA  of the elements in another  where their positions in that  satisfy a predicate ) traverseTail = elementsOf traverse (>0) d F transpose = transposeOf traverse -- modulo the ragged arrays support ( transposeOf _2 :: (b, [a]) -> [(b, a)] eBThis is the traversal that never succeeds at returning any values < traverseNothing :: Applicative f => (c -> f d) -> a -> f a f = traverseHead :: Applicative f => (a -> f a) -> [a] -> f [a] g A traverseTail :: Applicative f => ([a] -> f [a]) -> [a] -> f [a] h%Traverse the last element in a list.  # traverseLast = traverseValueAtMax = traverseLast :: Applicative f => (a -> f a) -> [a] -> f [a] i,Traverse all but the last element of a list A traverseInit :: Applicative f => ([a] -> f [a]) -> [a] -> f [a] j;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) k,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  l+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 m/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 n6Traverse a single element in a traversable container. Z traverseElement :: (Applicative f, Traversable t) => Int -> (a -> f a) -> t a -> f (t a) oWTraverse 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) p*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... q 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. 'We can focus Reader environments, too! q !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqd !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqdq !#"%$&'()*,+-./01;>=?@ABDCFE<23459678:HGIKJLOPMNQRSTUVWXYZ]^[\elmfghijknop_`abcdl !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopq RankNTypes provisionalEdward Kmett <ekmett@gmail.com>SaferGSometimes 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. uRepresentable Functors. A  f is u 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  u . @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 u  here. wThe representation of a u  as Lenses xx# 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 yy# 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 zz# 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 u   . distributeRep wf = rep $ \i -> fmap (^.i) wf Typical Usage: ! instance Distributive ... where  distribute = distributeRep }A u . has a fixed shape. This fills each position  in it with a r ~ Map over a u " with access to the lens for the  current position ) mapWithKey f m = rep $ \i -> f i (m^.i)  Traverse a u ! with access to the current path  Traverse a u ! with access to the current path " as a lens, discarding the result  Traverse a u ! with access to the current path ( and a lens (and the arguments flipped)  over a u ! with access to the current path  as a lens  over a u ! with access to the current path " as a lens, discarding the result  over a u ! with access to the current path ( as a lens (with the arguments flipped)  Fold over a u ! with access to the current path  as a lens, yielding a   Fold over a u ! 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. rstuvwxyz{|}~rstuvwxyz{|}~uvwxyz{|rst}~rstuvwxyz{|}~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuuvwxyz{|}~lens-0.8Control.Lens.THControl.Lens.Internal Control.LensControl.Lens.RepresentableData.Distributive distribute makeLenses makeLensesFor makeLensesBy Traversed getTraversed AppliedStaterunAppliedState IndexedStoreFocusing unfocusingTraverseValueAtMaxtraverseValueAtMaxTraverseValueAtMintraverseValueAtMinTraverseByteStringtraverseByteString TraversalFoldFocusfocusfocus_SetterGetterSimpleLenslensisotoviewviews^$^.mappedsetsadjustset=%==~==+==*==-==/==||==&&==|==&=_1_2valueAt valueAtIntcontains containsIntidentitybitAtresultAtaccess%%=~=%=+=-=*=//=&&=||=&=|=foldingfolded foldMapOffoldOffoldrOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOfmapMOf sequenceAOf sequenceOf elementOf elementsOf transposeOftraverseNothing traverseHead traverseTail traverseLast traverseInit traverseLeft traverseRighttraverseValueAttraverseValueAtInttraverseElementtraverseElements traverseBitscloneKeyturn RepresentablerepRepfmapReppureRepapRepbindRep distributeRepkeys mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithRepbase Control.MonadmapM_GHC.BaseFunctor$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusing Data.FoldableFoldable Data.MonoidMonoidghc-prim GHC.Classes|| GHC.TypesBool&& Data.Bits.|..&.containers-0.4.2.1Data.MapMap Data.IntMapIntMapData.SetSet Data.IntSetIntSetControl.Applicative ApplicativeData.Traversabletraverse$fFocusReaderT$fTraverseValueAtMaxSeq$fTraverseValueAtMax[]$fTraverseValueAtMaxIntMap$fTraverseValueAtMaxMap$fTraverseValueAtMinSeq$fTraverseValueAtMin[]$fTraverseValueAtMinIntMap$fTraverseValueAtMinMap$fTraverseByteStringByteString$fTraverseByteStringByteString0 $fFocusStateT$fFocusStateT0fmappurereturnmapM$fRepresentable(->)$fRepresentableIdentity