5%`      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\ ] ^ _ ! Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered "Used to find the nth element of a  Traversal. 2The result of trying to find the nth element of a  Traversal.  Used for  maximumOf  Used for  minimumOf Used internally by ` and the like. Used internally by  traverseOf_, ` and the like. Applicative composition of  State Int with a 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 ) bcdefghijklm       bcdefghijklm Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered% is just a renamed n functor to give better error = messages when someone attempts to use a getter as a setter. ">Anything Settable must be isomorphic to the Identity Functor. $ ( 'SimpleSetting' m = 'Simple' 'Setting' % $ 'SimpleSetter' = 'Simple' 'Setter' &5Running a Setter instantiates it to a concrete type. (When consuming a setter, use this type. ' The only Lens-like law that can apply to a ' l is that  ! set l c (set l b a) = set l c a You can't view 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 pure = pure # l f . run . l g = l (f . run . g) You can compose a ' with a Lens or a  Traversal using (.) from the Prelude ! and the result is always only a ' and nothing more. (;This setter can be used to map over all of the values in a a.  fmap = adjust mapped  fmapDefault = adjust traverse  (<$) = set mapped ))Build a Setter from a map-like function. Your supplied function f is required to satisfy:   f id = id  f g . f h = f (g . h) Equational reasoning:   sets . adjust = id  adjust . sets = id Another way to view ) is that it takes a 'semantic editor combinator'  and transforms it into a '. *Modify the target of a Lens or all the targets of a ' or  Traversal  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 Another way to view *" is to say that it transformers a ' into a  "semantic editor combinator". +Modify the target of a Lens or all the targets of a ' or  Traversal 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 4 mapOf :: Setter a b c d -> (c -> d) -> a -> b 4 mapOf :: Iso a b c d -> (c -> d) -> a -> b 4 mapOf :: Lens a b c d -> (c -> d) -> a -> b 4 mapOf :: Traversal a b c d -> (c -> d) -> a -> b ,Replace the target of a Lens or all of the targets of a '  or  Traversal 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 -Modifies the target of a Lens or all of the targets of a ' or   Traversal with a user supplied function. This is an infix version of *   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 .Replace the target of a Lens or all of the targets of a '  or  Traversal with a constant value. This is an infix version of , , provided for consistency with '(.=)'   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 Lens, Setter' or  Traversal  ghci> _1 +~ 1 $ (1,2)  (2,2) 0/Multiply the target(s) of a numerically valued Lens, Iso, ' or  Traversal _2 *~ 4 $ (1,2)(1,8)10Decrement the target(s) of a numerically valued Lens, Iso, ' or  Traversal _1 -~ 2 $ (1,2)(-1,2)2-Divide the target(s) of a numerically valued Lens, Iso, ' or  Traversal 3,Raise the target(s) of a numerically valued Lens, ' or  Traversal" to a non-negative integral power _2 ^~ 2 $ (1,3)(1,9)4-Raise the target(s) of a fractionally valued Lens, ' or  Traversal to an integral power _2 ^^~ (-1) $ (1,2)(1,0.5)5/Raise the target(s) of a floating-point valued Lens, ' or  Traversal to an arbitrary power. _2 **~ pi $ (1,3)(1,31.54428070019754)6 Logically o the target(s) of a p-valued Lens or ' 7 Logically q the target(s) of a p-valued Lens or ' 8,Modify the target of a monoidally valued by ring another value. 9Replace the target of a Lens or all of the targets of a ' or  Traversal 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 () 9It puts the state in the monad or it gets the hose again. :Map over the target of a Lens or all of the targets of a ' or ' Traversal in our monadic state. G (%=) :: MonadState a m => Iso a a c d -> (c -> d) -> m () G (%=) :: MonadState a m => Lens a a c d -> (c -> d) -> m () G (%=) :: MonadState a m => Traversal a a c d -> (c -> d) -> m () G (%=) :: MonadState a m => Setter a a c d -> (c -> d) -> m () ;Modify the target(s) of a Simple Lens, Iso, ' or  Traversal by adding a value  Example:  fresh = do  id += 1  access id <Modify the target(s) of a Simple Lens, Iso, ' or  Traversal by subtracting a value =Modify the target(s) of a Simple Lens, Iso, ' or  Traversal by multiplying by value >Modify the target(s) of a Simple Lens, Iso, ' or  Traversal by dividing by a value ?,Raise the target(s) of a numerically valued Lens, ' or  Traversal" to a non-negative integral power @,Raise the target(s) of a numerically valued Lens, ' or  Traversal to an integral power A,Raise the target(s) of a numerically valued Lens, ' or  Traversal to an arbitrary power BModify the target(s) of a Simple Lens, Iso, ' or  Traversal by taking their logical q with a value CModify the target(s) of a Simple Lens, 'Iso, ' or  Traversal by taking their logical o with a value DModify the target(s) of a Simple Lens, Iso, ' or  Traversal by r ing a value. E6Run a monadic action, and set all of the targets of a Lens, ' or  Traversal to its result.  < (<~) :: MonadState a m => Iso a a c d -> m d -> m () < (<~) :: MonadState a m => Lens a a c d -> m d -> m () < (<~) :: MonadState a m => Traversal a a c d -> m d -> m () < (<~) :: MonadState a m => Setter a a c d -> m d -> m () cAs a reasonable mnemonic, this lets you store the result of a monadic action in a lens rather than  in a local variable.   do foo <- bar  ... +will store the result in a variable, while   do foo <~ bar  ... will store the result in a lenssetter traversal. FTell a part of a value to a s, filling in the rest from t % whisper l d = tell (set l d mempty) . !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFuvwxyz( !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF('"#& !)(*+,.-/1023456789:;<=>?@ACBDEF%$+ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFuvwxyz Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedG = type SimpleOverloaded k f a b = Simple (Overloaded k f) a b H 5 type LensLike f a b c d = Overloaded (->) f a b c d IThis class allows us to use J. on a number of different monad transformers. JIRun a monadic action in a larger context than it was defined in, using a P Q or P  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  TraversalM 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 KLike J4, 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 () LA much more limited version of J that can work with a '. MMany combinators that accept a Q can also accept a  Traversal in limited situations. 'They do so by specializing the type of a" that they require of the caller. If a function accepts a M f a b c d for some a f, then they may be passed a Q.  Further, if f is an {, they may also be passed a  Traversal. N - type SimpleLensLike f = Simple (LensLike f) O  type SimpleLens = Simple Lens PA P Q, P  Traversal, ... can be used instead of a Q, Traversal, ...  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 M f or Setter, you may have to turn on  LiberalTypeSynonyms. QA Q+ is actually a lens family as described in  /http://comonad.com/reader/2012/mirrored-lenses/. 2With great power comes great responsibility and a Q1 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 Q. 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 Q can be used directly as a ' or  Traversal. You can also use a Q for Getting as if it were a Fold or Getter. Since every lens is a valid  TraversalA, 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 RBuild a Q from a getter and a setter. J lens :: Functor f => (a -> c) -> (a -> d -> b) -> (c -> f d) -> a -> f b S(S') can be used in one of two scenarios: When applied to a Q , it can edit the target of the Q in a structure, extracting a  functorial result. When applied to a  Traversal!, 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  Traversal!, 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) TModify the target of a Q: in the current state returning some extra information of c or  modify all targets of a  Traversal< 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 (T>), 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 UJThis 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) VAs U&, 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) WHThis lens can be used to change the result of a function but only where $ the arguments match the key given. X9Merge two lenses, getters, setters, folds or traversals. YY6 makes a lens from two other lenses (or isomorphisms) Z Cloning a Q) is one way to make sure you arent given  something weaker, such as a  Traversal and can be used ? as a way to pass around lenses that have to be monomorphic in f. !Note: This only accepts a proper Q , because  lacks its $ (admissable) Applicative instance. GHIJKLMNOPQRSTUVWXYZ|}~GHIJKLMNOPQRSTUVWXYZQPRSTUVWIJKLZXYMHONGGHIJKLMNOPQRSTUVWXYZ|}~ Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered [ Used instead of Const to report '"no instance of (Settable Accessor)' when  attempting to misuse a Setter as a a. ^LGeneralizing Const so we can apply simple Applicative transformations to it ( and so we can get nicer error messages `Most a- combinators are able to be used with both a a or a Fold in S limited situations, to do so, they need to be monomorphic in what we are going to  extract with . To be compatible with Q,  Traversal and Iso we also : restricted choices of the irrelevant b and d parameters. If a function accepts a Getting m r a b c d , then when r is a Monoid, and m is a   you can pass a Fold (or  Traversal&), otherwise you can only pass this a  a or Q. aA aM describes how to retrieve a single value in a way that can be composed with  other lens-like constructions.  Unlike a Q a a is read-only. Since a a cannot be used to write back 3 there are no lens laws that can be applied to it.  Moreover, a a can be used directly as a Fold, since it just ignores the . bBuild a a% from an arbitrary Haskell function.   to f . to g = to (g . f)  a^.to f = f a (0, -5)^._2.to abs5cView the value pointed to by a a, Iso or Q or the result of folding over  all the results of a Fold or  Traversal# that points at a monoidal values. It may be useful to think of c. as having these more restrictive signatures:   view . to = id view _2 (1,"hello")"hello" 3 view :: Getter a c -> a -> c 3 view :: Monoid m => Fold a m -> a -> m 3 view :: Iso a b c d -> a -> c 3 view :: Lens a b c d -> a -> c 3 view :: Monoid m => Traversal a b m d -> a -> m dView the value of a a, Iso, Q# or the result of folding over the $ result of mapping the targets of a Fold or  Traversal. It may be useful to think of d. as having these more restrictive signatures: views _2 length (1,"hello")5 @ 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 eView the value pointed to by a a, Iso or Q or the result of folding over  all the results of a Fold or  Traversal# that points at a monoidal values. This is the same operation as c, only infix. _2 ^$ (1, "hello")"hello" 3 (^$) :: Getter a c -> a -> c 3 (^$) :: Monoid m => Fold a m -> a -> m 3 (^$) :: Iso a b c d -> a -> c 3 (^$) :: Lens a b c d -> a -> c 3 (^$) :: Monoid m => Traversal a b m d -> a -> m fView the value pointed to by a a or Q or the result of folding over  all the results of a Fold or  Traversal# that points at a monoidal values. This is the same operation as c with the arguments flipped. HThe fixity and semantics are such that subsequent field accesses can be  performed with (Prelude..) $((0, 1 :+ 2), 3)^._1._2.to magnitude2.23606797749979 3 (^.) :: a -> Getter a c -> c 3 (^.) :: Monoid m => a -> Fold a m -> m 3 (^.) :: a -> Iso a b c d -> c 3 (^.) :: a -> Lens a b c d -> c 3 (^.) :: Monoid m => a -> Traversal a b m d -> m gQuery the target of a Q, Iso or a in the current state, or use a  summary of a Fold or  Traversal" 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 hUse the target of a Q, Iso or a in the current state, or use a  summary of a Fold or  Traversal" 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 iUse the target of a Q, Iso, or a in the current state, or use a  summary of a Fold or  Traversal" that points to a monoidal value. ? use :: MonadState a m => Action m a b -> m b ? 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 jUse the target of a Q, Iso or a in the current state, or use a  summary of a Fold or  Traversal" that points to a monoidal value. L uses :: MonadState a m => Action m a c -> (c -> e) -> m e 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 [\]^_`abcdefghij[\]^_`abcdefghija`^_[\]bfecdijgh[\]^_`abcdefghij Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered4kSomething we can fold. nA nI describes how to retrieve multiple values in a way that can be composed % with other lens-like constructions. A n a cC provides a structure with operations very similar to those of the   typeclass, see { and the other n combinators. !By convention, if there exists a foo method that expects a  (f c), then there should be a  fooOf method that takes a n a c and a value of type a. A a is a legal n that just ignores the supplied   Unlike a  Traversal a n is read-only. Since a n cannot be used to write back $ there are no lens laws that apply. oBuild a a or n from a -like function. H folds :: ((c -> r) -> a -> r) -> (c -> Accessor m d) -> a -> Const m b p Obtain a n9 by lifting an operation that returns a foldable result. +This can be useful to lift operations from  Data.List and elsewhere into a n. q Obtain a n from any .  folded = folds foldMap r%Fold by repeating the input forever.  repeat = toListOf repeated s!A fold that replicates its input n times. ' replicate n = toListOf (replicated n) tITransform 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,..] u2Build a fold that unfolds its values from a seed. % ghci> unfoldr = toListOf . unfolded vx ^. v f5 Return an infinite fold of repeated applications of f to x. ' toListOf (iterated f) a = iterate f a w Obtain a n by filtering a Q, Iso, a, n or  Traversal. x.This allows you to traverse the elements of a  Traversal or n in the opposite order. Note: x should have no impact on a a Setter, Q or Iso. To change the direction of an Iso, use from. y Obtain a n! by taking elements from another n, Q, Iso, a or  Traversal while a predicate holds.  / takeWhile p = toListOf (takingWhile p folded) / ghci> toList (takingWhile (<=3) folded) [1..]  [1,2,3] z Obtain a n# by dropping elements from another n, Q, Iso, a or  Traversal 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 B foldMapOf :: Getter a c -> (c -> r) -> a -> r B foldMapOf :: Monoid r => Fold a c -> (c -> r) -> a -> r B foldMapOf :: Lens a b c d -> (c -> r) -> a -> r B foldMapOf :: Iso a b c d -> (c -> r) -> a -> r B foldMapOf :: Monoid r => Traversal a b c d -> (c -> r) -> a -> r |  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 Q, a, n or  Traversal.   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 Q, a, n or  Traversal.   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 a,  can work over a a. When passed a n,  requires an {.   traverse_ = traverseOf_ folded  > traverseOf_ _2 :: Functor f => (c -> f e) -> (c1, c) -> f () O traverseOf_ traverseLeft :: Applicative f => (a -> f b) -> Either a c -> f () bThe rather specific signature of traverseOf_ allows it to be used as if the signature was either: N traverseOf_ :: Functor f => Getter a c -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Fold a c -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Lens a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Functor f => Iso a b c d -> (c -> f e) -> a -> f () N traverseOf_ :: Applicative f => Traversal a b c d -> (c -> f e) -> a -> f ()   for_ = forOf_ folded I forOf_ :: Functor f => Getter a c -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Fold a c -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Lens a b c d -> a -> (c -> f e) -> f () I forOf_ :: Functor f => Iso a b c d -> a -> (c -> f e) -> f () I forOf_ :: Applicative f => Traversal a b c d -> a -> (c -> f e) -> f ()  " sequenceA_ = sequenceAOf_ folded F sequenceAOf_ :: Functor f => Getter a (f ()) -> a -> f () F sequenceAOf_ :: Applicative f => Fold a (f ()) -> a -> f () F sequenceAOf_ :: Functor f => Lens a b (f ()) d -> a -> f () F sequenceAOf_ :: Functor f => Iso a b (f ()) d -> a -> f () F sequenceAOf_ :: Applicative f => Traversal a b (f ()) d -> a -> f ()   mapM_ = mapMOf_ folded D mapMOf_ :: Monad m => Getter a c -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Fold a c -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Lens a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Iso a b c d -> (c -> m e) -> a -> m () D mapMOf_ :: Monad m => Traversal a b c d -> (c -> m e) -> a -> m ()   forM_ = forMOf_ folded D forMOf_ :: Monad m => Getter a c -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Fold a c -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Lens a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Iso a b c d -> a -> (c -> m e) -> m () D forMOf_ :: Monad m => Traversal a b c d -> a -> (c -> m e) -> m ()   sequence_ = sequenceOf_ folded > sequenceOf_ :: Monad m => Getter a (m b) -> a -> m () > sequenceOf_ :: Monad m => Fold a (m b) -> a -> m () > sequenceOf_ :: Monad m => Lens a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Iso a b (m b) d -> a -> m () > sequenceOf_ :: Monad m => Traversal a b (m b) d -> a -> m () 1The sum of a collection of actions, generalizing .   asum = asumOf folded : asumOf :: Alternative f => Getter a c -> a -> f c : asumOf :: Alternative f => Fold a c -> a -> f c : asumOf :: Alternative f => Lens a b c d -> a -> f c : asumOf :: Alternative f => Iso a b c d -> a -> f c : asumOf :: Alternative f => Traversal a b c d -> a -> f c 1The sum of a collection of actions, generalizing .   msum = msumOf folded 8 msumOf :: MonadPlus m => Getter a c -> a -> m c 8 msumOf :: MonadPlus m => Fold a c -> a -> m c 8 msumOf :: MonadPlus m => Lens a b c d -> a -> m c 8 msumOf :: MonadPlus m => Iso a b c d -> a -> m c 8 msumOf :: MonadPlus m => Traversal a b c d -> a -> m c   elem = elemOf folded 7 elemOf :: Eq c => Getter a c -> c -> a -> Bool 7 elemOf :: Eq c => Fold a c -> c -> a -> Bool 7 elemOf :: Eq c => Lens a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Iso a b c d -> c -> a -> Bool 7 elemOf :: Eq c => Traversal a b c d -> c -> a -> Bool   notElem = notElemOf folded : notElemOf :: Eq c => Getter a c -> c -> a -> Bool : notElemOf :: Eq c => Fold a c -> c -> a -> Bool : notElemOf :: Eq c => Iso a b c d -> c -> a -> Bool : notElemOf :: Eq c => Lens a b c d -> c -> a -> Bool : notElemOf :: Eq c => Traversal a b c d -> c -> a -> Bool   concatMap = concatMapOf folded < concatMapOf :: Getter a c -> (c -> [e]) -> a -> [e] < concatMapOf :: Fold a c -> (c -> [e]) -> a -> [e] < concatMapOf :: Lens a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Iso a b c d -> (c -> [e]) -> a -> [e] < concatMapOf :: Traversal a b c d -> (c -> [e]) -> a -> [e]   concat = concatOf folded - concatOf :: Getter a [e] -> a -> [e] - concatOf :: Fold a [e] -> a -> [e] - concatOf :: Iso a b [e] d -> a -> [e] - concatOf :: Lens a b [e] d -> a -> [e] - concatOf :: Traversal a b [e] d -> a -> [e] ;Note: this can be rather inefficient for large containers.   length = lengthOf folded   lengthOf _1 :: (a, b) -> Int  lengthOf _1 = 1 : lengthOf (folded.folded) :: Foldable f => f (g a) -> Int + lengthOf :: Getter a c -> a -> Int + lengthOf :: Fold a c -> a -> Int + lengthOf :: Lens a b c d -> a -> Int + lengthOf :: Iso a b c d -> a -> Int + lengthOf :: Traversal a b c d -> a -> Int Perform a safe  of a n or  Traversal or retrieve  the result  from a a or Q.  & listToMaybe . toList = headOf folded - headOf :: Getter a c -> a -> Maybe c - headOf :: Fold a c -> a -> Maybe c - headOf :: Lens a b c d -> a -> Maybe c - headOf :: Iso a b c d -> a -> Maybe c - headOf :: Traversal a b c d -> a -> Maybe c Perform a safe  of a n or  Traversal or retrieve  the result  from a a or Q. - 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  if this n or  Traversal( has no targets in the given container. Note: nullOf on a valid Iso, Q or a should always return    null = nullOf folded /This may be rather inefficient compared to the  check of many containers.   nullOf _1 :: (a, b) -> Int  nullOf _1 = False ? nullOf (folded._1.folded) :: Foldable f => f (g a, b) -> Bool * nullOf :: Getter a 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 n or  Traversal Note: maximumOf on a valid Iso, Q or a will always return  a value.  8 maximum = fromMaybe (error "empty") . maximumOf folded 9 maximumOf :: Getter a c -> a -> Maybe c 9 maximumOf :: Ord c => Fold a c -> a -> Maybe c 9 maximumOf :: Iso a b c d -> a -> Maybe c 9 maximumOf :: Lens a b c d -> a -> Maybe c 9 maximumOf :: Ord c => Traversal a b c d -> a -> Maybe c 2Obtain the minimum element (if any) targeted by a n or  Traversal Note: minimumOf on a valid Iso, Q or a will always return  a value.  8 minimum = fromMaybe (error "empty") . minimumOf folded 9 minimumOf :: Getter a c -> a -> Maybe c 9 minimumOf :: Ord c => Fold a c -> a -> Maybe c 9 minimumOf :: Iso a b c d -> a -> Maybe c 9 minimumOf :: Lens a b c d -> a -> Maybe c 9 minimumOf :: Ord c => Traversal a b c d -> a -> Maybe c 2Obtain the maximum element (if any) targeted by a n,  Traversal, Q, Iso,  or a( 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 n,  Traversal, Q, Iso  or a( 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  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 8klmnopqrstuvwxyz{|}~6klmnopqrstuvwxyz{|}~6nklmopquvwxrstyz{|}~6klmnopqrstuvwxyz{|}~"rank 2 types, MPTCs, TFs, flexible provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered type 'SimpleIdexedTraversal i = P ( i)'Every indexed Setter is a valid Setter ,The Setter laws are still required to hold. type 'SimpleIdexedTraversal i = P ( i)>Every indexed traversal is a valid Traversal or indexed fold. /The Traversal laws are still required to hold. Every  is a valid Fold. 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 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 Q, a, Fold or  Traversal. 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 Map with index F mapWithIndexOf :: IndexedSetter i a b c d -> (i -> c -> d) -> a -> b  (%@) = mapWithIndexOf CUsing an equality witness to avoid potential overlapping instances  and aid dispatch. portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis Q4 can be used to read, write or delete a member of a  ,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  Traversal for a , but you can  manipulate it by reading using q and reindexing it via setmap. *adjust setmapped (+1) (fromList [1,2,3,4])fromList [2,3,4,5]Construct a set from a a, n,  Traversal, Q or Iso. 5setOf (folded._2) [("hello",1),("world",2),("!!!",3)]fromList [1,2,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  Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered ) type SimpleTraversal = Simple Traversal A  can be used directly as a Setter or a n (but not as a Q) and provides V the ability to both read and update multiple fields, subject to some relatively weak  laws. UThese have also been known as multilenses, but they have the signature and spirit of  8 traverse :: Traversable f => Traversal (f a) (f b) a b 8and the more evocative name suggests their application. Most of the time the  you will want to use is just , but you can also pass any  Q or Iso& as a Traversal, and composition of a  (or Q or Iso ) with a  (or Q or Iso)  using (.) forms a valid . 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. AMap each element of a structure targeted by a Lens or Traversal, E evaluate these actions from left to right, and collect the results.   traverseOf = id   traverse = traverseOf traverse ; traverseOf :: Iso a b c d -> (c -> f d) -> a -> f b ; traverseOf :: Lens a b c d -> (c -> f d) -> a -> f b ; traverseOf :: Traversal a b c d -> (c -> f d) -> a -> f b   forOf l = flip (traverseOf l)   for = forOf traverse  forOf = morphism flip flip 1 forOf :: Lens a b c d -> a -> (c -> f d) -> f b FEvaluate each action in the structure from left to right, and collect  the results.  " sequenceA = sequenceAOf traverse ! sequenceAOf l = traverseOf l id  sequenceAOf l = l id C sequenceAOf :: Iso a b (f c) c -> a -> f b C sequenceAOf :: Lens a b (f c) c -> a -> f b C sequenceAOf :: Applicative f => Traversal a b (f c) c -> a -> f b HMap each element of a structure targeted by a lens to a monadic action, E evaluate these actions from left to right, and collect the results.   mapM = mapMOf traverse B mapMOf :: Iso a b c d -> (c -> m d) -> a -> m b B mapMOf :: Lens a b c d -> (c -> m d) -> a -> m b B mapMOf :: Monad m => Traversal a b c d -> (c -> m d) -> a -> m b   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   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 This generalizes !" to an arbitrary .  " transpose = transposeOf traverse  . ghci> transposeOf traverse [[1,2,3],[4,5,6]]  [[1,4],[2,5],[3,6]]  Since every Q. is a Traversal, we can use this as a form of  monadic strength. ( transposeOf _2 :: (b, [a]) -> [(b, a)]  Generalizes  to an arbitrary .  " mapAccumR = mapAccumROf traverse ' accumulates state from right to left. L mapAccumROf :: 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)  Generalized  to an arbitrary .  " mapAccumL = mapAccumLOf traverse ' 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) Permit the use of  over an arbitrary  or Q.   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 Permit the use of  over an arbitrary  or Q.   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 A Q to view/edit the nth element  a , Q or Iso. +Attempts to access beyond the range of the  will cause an error. 4 ghci> [[1],[3,4]]^.elementOf (traverse.traverse) 1  3 Access the nth element of a  container. +Attempts to access beyond the range of the  will cause an error.  element = elementOf traverse %This is the traversal that just doesn't return anything < traverseNothing :: Applicative f => (c -> f d) -> a -> f a   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedThis QK can be used to read, write or delete the value associated with a key in a . (Map.fromList [("hello",12)] ^.at "hello"Just 12!at 10 .~ Just "hello" $ Map.emptyfromList [(10,"hello")] H at :: Ord k => k -> (Maybe v -> f (Maybe v)) -> Map k v -> f (Map k v) Traversal of a  indexed by the key. +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 0Traverse the value at the minimum key in a Map. KThe key of the minimum element is available as the index of the traversal. 0Traverse the value at the maximum key in a Map. KThe key of the maximum element is available as the index of the traversal.  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 . 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   Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered % type SimpleIso a b = Simple Iso a b BIsomorphim families can be composed with other lenses using either' (.)' and  I from the Prelude or from Control.Category. However, if you compose them  with each other using '(.)'1 from the Prelude, they will be dumbed down to a  mere Lens.   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 'A concrete data type for isomorphisms. DThis lets you place an isomorphism inside a container without using ImpredicativeTypes. 7Used to provide overloading of isomorphism application  This is a ) with a canonical mapping to it from the . category of isomorphisms over Haskell types. *Build this morphism out of an isomorphism The intention is that by using #, you can supply both halves of an G isomorphism, but k can be instantiated to (->), so you can freely use * the resulting isomorphism as a function. MMap a morphism in the target category using an isomorphism between morphisms  in Hask. Invert an isomorphism. ENote to compose an isomorphism and receive an isomorphism in turn you'll need to use     from (from l) = l If you imported 'Control.Category.(.)', then:   from l . from r = from (r . l)  from :: (a :~> b) -> (b :~> a) % via :: Isomorphism a b -> (a :~> b) @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 n.  x^.identity = Identity x  Identity x^.from identity = x :This isomorphism can be used to wrap or unwrap a value in   x^._const = Const x  Const x^.from _const = x    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 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 a,  that is to say  x = Rep f is a valid choice of x for every   a. @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  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  a  . distributeRep wf = rep $ \i -> fmap (^.i) wf Typical Usage: ! instance Distributive ... where  distribute = distributeRep A  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 Key , however.  Map over a  a" with access to the lens for the  current position ) mapWithKey f m = rep $ \i -> f i (m^.i)  Traverse a  a! with access to the current path  Traverse a  a! with access to the current path " as a lens, discarding the result  Traverse a  a! with access to the current path ( and a lens (and the arguments flipped)  over a  a! with access to the current path  as a lens  over a  a! with access to the current path " as a lens, discarding the result  over a  a! with access to the current path ( as a lens (with the arguments flipped)  Fold over a  a! with access to the current path  as a lens, yielding a   Fold over a  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.  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 P Q 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. Default lens rules )Build lenses with a custom configuration 3Build lenses with a sensible default configuration ' makeLenses = makeLensesWith lensRules 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 # makeIso = makeLensesWith isoRules 1Rules for making an isomorphism from a data type Make ' classy lenses' for a type ) makeClassy = makeLensesWith classyRules 6Rules for making lenses that precompose another lens. /Derive lenses, specifying explicit pairings of (fieldName, lensName). Example usage: < makeLensesFor [("_foo", "fooLens"), ("bar", "lbar")] ''Foo pRules for making fairly simple lenses, ignoring the special cases for isomorphisms, and not making any classes. /Derive lenses, specifying explicit pairings of (fieldName, lensName)  using a wrapper class. Example usage: K makeClassyFor "HasFoo" "foo" [("_foo", "fooLens"), ("bar", "lbar")] ''Foo                       % Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     portable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedTraverse the strongly typed  contained in ) where the type of your function matches  the desired . @ traverseException :: (Applicative f, Exception a, Exception b) E => (a -> f b) -> SomeException -> f SomeException LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedBitwise  the target(s) of a p-valued Q or ' _2 |~ 6 $ ("hello",3) ("hello",7)Bitwise  the target(s) of a p-valued Q or ' _2 &~ 7 $ ("hello",254) ("hello",6)Modify the target(s) of a P Q, ' or  by computing its bitwise  with another value. Modify the target(s) of a P Q, ' or  by computing its bitwise  with another value. FThis lens can be used to access the value of the nth bit in a number. bitAt n is only a legal Q into b if 0 <= n < bitSize (undefined :: b)  16^.bitAt 4True 15^.bitAt 4False*Traverse over all bits in a numeric type. ,The bit position is available as the index. "toListOf traverseBits (5 :: Word8)/[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.  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 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 ####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 [1,2,3]^._head1',A lens reading and writing to the tail of a  non-empty list _tail .~ [3,4,5] $ [1,2] [1,3,4,5](4A lens reading and writing to the last element of a  non-empty list  [1,2]^._last2)=A lens reading and replacing all but the a last element of a  non-empty list [1,2,3,4]^._init[1,2,3]*CObtain a version of the list with the supplied value interspersed. "abcde"^.interspersed ',' "a,b,c,d,e" ' xs^.interspersed a = intersperse a xs +BObtain a version of the list with the supplied value intercalated ,QIndexed traversal of a list. The position in the list is available as the index. -<The traversal for reading and writing to the head of a list MThe position of the head in the original list (0) is available as the index. traverseHead +~ 1 $ [1,2,3][2,2,3] = traverseHead :: Applicative f => (a -> f a) -> [a] -> f [a] .*Traversal for editing the tail of a list. The position of each element in the original list is available as the index. traverseTail +~ 1 $ [1,2,3][1,3,4] = traverseTail :: Applicative f => (a -> f a) -> [a] -> f [a] /%Traverse the last element in a list. QThe position of the last element in the original list is available as the index. traverseLast +~ 1 $ [1,2,3][1,2,4] = traverseLast :: Applicative f => (a -> f a) -> [a] -> f [a] 0,Traverse all but the last element of a list 8The position of each element is available as the index. traverseInit +~ 1 $ [1,2,3][2,3,3] = traverseInit :: Applicative f => (a -> f a) -> [a] -> f [a] &'()*+,-./0 &'()*+,-./0 &'()*+,-.0/ &'()*+,-./0portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered14Traverse both parts of a tuple with matching types. 2This provides a ) that checks a predicate on a key before ( allowing you to traverse into a value. 12121212 Rank2Types provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered3This QL can be used to read, write or delete the value associated with a key in an . fromList [(1,"hello")] ^.at 1 Just "hello"#at 1 .~ Just "hello" $ IntMap.emptyfromList [(1,"hello")] C at :: Int -> (Maybe v -> f (Maybe v)) -> IntMap v -> f (IntMap v) 4Traversal of an  indexed by the key. 5/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 6/Traverse the value at the minimum key in a Map :The key of the minimum element is available as the index. 7/Traverse the value at the maximum key in a Map 34567345673456734567portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered8This Q5 can be used to read, write or delete a member of an   0 ghci> contains 3 +~ False $ fromList [1,2,3,4]  fromList [1,2,4] ; contains :: Int -> (Bool -> f Bool) -> IntSet -> f IntSet 9 IntSet isn't Foldable, but this n) can be used to access the members of an . &sumOf members $ setOf folded [1,2,3,4]10:This '* can be used to change the contents of an  by mapping  the elements to new values. Sadly, you can't create a valid  for a Set, because the number of B elements might change but you can manipulate it by reading using q and  reindexing it via setmap. *adjust setmapped (+1) (fromList [1,2,3,4])fromList [2,3,4,5]; Construct an  from a a, n, , Q or . - setOf :: Getter a Int -> a -> IntSet - setOf :: Fold a Int -> a -> IntSet - setOf :: Iso a b Int d -> a -> IntSet - setOf :: Lens a b Int d -> a -> IntSet - setOf :: Traversal a b Int d -> a -> IntSet 89:;89:;89:;89:;portable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered <A Q 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  ATraverse the last element of a  B'Traverse all but the last element of a  CTraverse the first n elements of a  DTraverse all but the first n elements of a  E'Travere all the elements numbered from i to j of a  <=>?@ABCDE <=>?@ABCDE <=>?@ABCDE <=>?@ABCDEMTPCs provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedFA Q that focuses on the root of a . GA , of the direct descendants of the root of a  1 indexed by its position in the list of children FGFGFGFG&MPTCs, Rank2Types, LiberalTypeSynonyms provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedHAccess 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 'ix 2 ^= 9 $ listArray (1,5) [4,5,6,7,8]array (1,5) [4,9,6,7,8]ICThis 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 '.   ixmap = adjust . ixmapped  ixmapped = sets . ixmap + adjust (ixmapped b) f arr ! i = arr ! f i ( bounds (adjust (ixmapped b) f arr) = b JGeneric 7 of the elements of an array, using the index into the & array as the index of the traversal.  amap = adjust traverseArray HIJHIJHIJHIJportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedK(Pack (or unpack) a list of bytes into a   pack x = x^.packedBytes  unpack x = x^.from packedBytes L#Traverse the individual bytes in a   % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool M-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 N#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 KLMNKLMNKLMNKLMNportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedO(Pack (or unpack) a list of bytes into a   pack x = x^.packedBytes  unpack x = x^.from packedBytes P#Traverse the individual bytes in a   % bytes = from packedBytes . traverse , anyOf bytes (==0x80) :: ByteString -> Bool Q-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 R#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 OPQROPQROPQROPQRportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedSPack (or unpack) .  pack x = x^.packed  unpack x = x^.from packed T>Traverse the individual characters in a either strict or lazy . $ anyOf text (=='c') :: Text -> Bool STSTSTSTportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedUPack (or unpack) .  pack x = x^.packed  unpack x = x^.from packed V(Traverse the individual characters in a . $ anyOf text (=='c') :: Text -> Bool UVUVUVUVportable provisionalEdward Kmett <ekmett@gmail.com> Safe-InferedWEvaluate the targets of a Q or  into a data structure " according to the given strategy.  * evalTraversable = evalTraversal traverse   evalTraversal = id  > evalTraversal :: Simple Lens a b -> Strategy b -> Strategy a C evalTraversal :: Simple Traversal a b -> Strategy b -> Strategy a L evalTraversal :: (b -> Eval b) -> a -> Eval a) -> Strategy b -> Strategy a XEvaluate the targets of a Q or  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 Y Transform a Q, n, a, ' or  to P first evaluates its argument according to a given strategy, before proceeding.  after rdeepseq traverse Z Transform a Q, n, a, ' or  to R evaluate its argument according to a given strategy in parallel with evaluating.  meanwhile rdeepseq traverse WXYZWXYZWXYZWXYZportable provisionalEdward Kmett <ekmett@gmail.com> Safe-Infered[$Evaluate the elements targeted by a Q, , ,  a or n" according to the given strategy.  seqFoldable = seqOf folded [[[[ GHC experimentalEdward Kmett <ekmett@gmail.com> Safe-Infered\(Traversable generic data types. Used by _. ];Convert from the data type to its representation (or back) "hello"^.generic.from generic"hello"^;Convert from the data type to its representation (or back) _Traverse using GHC.Generics. ?allOf every (=="Hello") (1::Int,2::Double,(),"Hello",["Hello"])True7mapMOf_ every putStrLn ("hello",[(2 :: Int, "world!")])helloworld! \]^_\]^_]^_\ \]^_&'(&')**+,-./001223445667889::;;<=>??@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyzz{|}~                                             ! " # $ % & ' ( ) * + , - . / 0 123456789:;<=>?@ABCDEFGHIJKLMNOPGHIJQRSTUVWXYZ[\YZ[\]^]^_`abc d e f g&hi&jklmnopqrstuvwxyz{|}{~{|&&&&&j&&&&&&{~{~&&&'&'&&           &&   &j&&j&'  &&&&&      lens-1.5Control.Lens.TraversalControl.Lens.InternalControl.Lens.SetterControl.Lens.TypeControl.Lens.GetterControl.Lens.FoldControl.Lens.Indexed Data.Set.Lens Data.Map.LensLanguage.Haskell.TH.LensControl.Lens.IsoControl.Lens.RepresentableControl.Lens.THControl.Exception.LensData.Bits.LensData.Complex.LensData.Dynamic.LensData.Either.LensData.List.LensData.Pair.LensData.IntMap.LensData.IntSet.LensData.Sequence.LensData.Tree.LensData.Array.LensData.ByteString.LensData.ByteString.Lazy.LensData.Text.LensData.Text.Lazy.Lens Control.Parallel.Strategies.LensControl.Seq.LensGHC.Generics.Lens Data.List transposeData.Distributive distribute Control.LensbaseData.Traversable Traversabletraverse ElementOf getElementOfElementOfResultNotFoundFound SearchingMaxNoMaxMinNoMin Sequenced getSequenced Traversed getTraversed AppliedStaterunAppliedState IndexedStoreFocusing unfocusinggetMingetMaxMutator runMutatorSettablerun SimpleSetting SimpleSetterSettingSettermappedsetsadjustmapOfset%~.~+~*~-~//~^~^^~**~||~&&~<>~.=%=+=-=*=//=^=^^=**=&&=||=<>=<~whisperSimpleOverloaded OverloadedFocusfocusfocus_setFocusLensLikeSimpleLensLike SimpleLensSimpleLenslens%%~%%=_1_2resultAtmerged bothLensescloneAccessor runAccessorGettablecoerceGettingGettertoviewviews^$^.queryqueriesuseusesFurledfurledunfurledFoldfoldsfoldingfoldedrepeated replicatedcycledunfoldediteratedfiltered backwards takingWhile droppingWhile foldMapOffoldOffoldrOffoldlOftoListOfandOforOfanyOfallOf productOfsumOf traverseOf_forOf_ sequenceAOf_mapMOf_forMOf_ sequenceOf_asumOfmsumOfelemOf notElemOf concatMapOfconcatOflengthOfheadOflastOfnullOf maximumOf minimumOf maximumByOf minimumByOffindOffoldr1Offoldl1OffoldrOf'foldlOf'foldrMOffoldlMOfSimpleIndexedSetter IndexedSetterSimpleIndexedTraversalIndexedTraversal IndexedFoldIndex withIndex IndexableIndexedindexreindex.@composeWithIndexfoldMapWithIndexOffoldrWithIndexOftraverseWithIndexOfmapMWithIndexOfmapWithIndexOf%@contains setmappedsetOfSimpleTraversal Traversal traverseOfforOf sequenceAOfmapMOfforMOf sequenceOf transposeOf mapAccumROf mapAccumLOfscanr1Ofscanl1Of elementOfelementtraverseNothingat traverseMap traverseAt traverseAtMin traverseAtMax SubstType substType HasTypeVars typeVarsExHasNamenametypeVars substTypeVars SimpleIsoIso Isomorphism Isomorphic isomorphicisomapfromviaisosisoidentity_constPathwalk RepresentablerepRepfmapReppureRepapRepbindRep distributeReppaths tabulated mapWithReptraverseWithReptraverseWithRep_ forWithRep mapMWithRep mapMWithRep_ forMWithRepfoldMapWithRep foldrWithRep LensRulesLensFlag ClassRequiredCreateInstance CreateClassSingletonRequiredHandleSingletons SingletonIsoSingletonAndField SimpleLenses simpleLenseshandleSingletons singletonIsosingletonRequired createClasscreateInstance classRequiredlensIso lensField lensClass lensFlags defaultRulesmakeLensesWith makeLensesmakeIsoisoRules makeClassy classyRules makeLensesFor lensRules makeClassyFortraverseException|~&~&=|=bitAt traverseBitsreal imaginarypolarizetraverseComplextraverseDynamic traverseLeft traverseRight_head_tail_last_init interspersed intercalated traverseList traverseHead traverseTail traverseLast traverseInitbothvaluetraverseIntMapmembersviewLviewR traverseTo traverseFrom traverseSlicerootchildrenixixmapped traverseArray packedBytesbytes packedCharscharspackedtextevalOfparOfafter meanwhileseqOf GTraversalgenericgeneric1every Control.MonadmapM_GHC.BaseFunctor$fApplicativeElementOf$fFunctorElementOf$fFunctorElementOfResult $fMonoidMax $fMonoidMin$fMonoidSequenced$fMonoidTraversed$fApplicativeAppliedState$fFunctorAppliedState$fFunctorIndexedStore$fApplicativeFocusing$fFunctorFocusingtransformers-0.3.0.0Data.Functor.IdentityIdentityghc-prim GHC.Classes|| GHC.TypesBool&& Data.Monoidmappend mtl-2.1.2Control.Monad.Writer.Class MonadWritermempty$fSettableMutator$fApplicativeMutator$fFunctorMutator$fSettableCompose$fSettableBackwards$fSettableIdentityControl.Applicative Applicative$fFocusReaderT $fFocusStateT$fFocusStateT0ConstMonadMonoid$fApplicativeAccessor$fGettableAccessor$fFunctorAccessor$fGettableElementOf$fGettableCompose$fGettableBackwards$fGettableConst Data.FoldableFoldablefoldMapGHC.Listhead Data.MaybeJustlastTrueFalsenullNothing$fFurledDualBackwards$fFurledrAccessor$fIndexediIndex$fIndexedi(->)containers-0.4.2.1Data.SetSet mapAccumR mapAccumLscanr1scanl1Data.MapMaptemplate-haskellLanguage.Haskell.TH.SyntaxnewNameName$fSubstTypePred $fSubstType[]$fSubstTypeType$fHasTypeVars[]$fHasTypeVarsPred$fHasTypeVarsType$fHasTypeVarsName$fHasTypeVarsTyVarBndr $fHasNameCon $fHasNameName$fHasNameTyVarBndrControl.CategoryidCategory$fIsomorphicIsomorphism$fCategoryIsomorphism$fIsomorphic(->)fmappurereturnmapM$fRepresentable(->)$fRepresentableIdentity GHC.Exception Exception SomeException Data.Bits.|..&. Data.DynamicDynamic Data.IntMapIntMap Data.IntSetIntSet Data.SequenceSeqViewLViewR Data.TreeTreebytestring-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$fGTraversal:.:$fGTraversalM1$fGTraversal:+:$fGTraversal:*:$fGTraversalU1$fGTraversalK1