h$x      !"#$%& ' ( ) * + , - . / 01 2 3 456 78 9 : ; < = >?@A B C D E F G H I J K L M N O P Q R S T U V W XYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ !""""""""#########$$$$$%%%%%%%%%%%%&&'''''((((())**++,,,,,,,,,,,,,,,,,------------     ..........///////////////////////000000001111111111233333333333333333333333333333333333333334444444444444556667777777777777777777777888888888888888888888888889999999999888888888888888888888888888888888888888888888888::::::::::;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<======================>>>>>>>>>>>>>??????None'(059>?d optics-core#Class for contravariant bifunctors. optics-core!Class for (covariant) bifunctors. optics-coreIf p is a  and a * then its left parameter must be phantom. optics-coreIf p is a  and + then its right parameter must be phantom.  @ Safe-Inferred'(059>?   Safe-Inferred'(./059>?# optics-coreHow about a magic trick? I'm gonna make the coverage condition disappear.$ optics-coreIncluding the instance head in the context lifts the coverage condition for all type variables in the instance. A dirty trick until we have  7https://github.com/ghc-proposals/ghc-proposals/pull/374 and can do it properly.% optics-coreShow something useful when type inference goes into a loop and stops with "reduction stack overflow" message (sometimes happens when trying to infer types of local bindings when monomorphism restriction is enabled)."##"  Safe-Inferred'(./059>?& optics-coreDerive the shape of a from the shape of b.( optics-core(Show a symbol surrounded by quote marks.) optics-core&Show a type surrounded by quote marks.* optics-core Use with ++ to detect stuck (undefined) type families.+ optics-coreShow a custom type error if p is false (or stuck)., optics-coreShow a custom type error if p is true./ optics-core If lhs is !, return it. Otherwise check rhs.0 optics-core0In pseudo (dependent-)Haskell, provide a witness foldr f (foldr f init xs) ys = foldr f init (ys ++ xs) where f = (->) 2 optics-coreTagged version of 'Data.Type.Equality.(:~:)' for carrying evidence that two index lists in a curried form are equal.4 optics-core0Class that is inhabited by all type-level lists xs5, providing the ability to compose a function under 7 xs.5 optics-coreCompose a function under 7 xs. This generalises () (aka  for (->)) to work for curried functions with one argument for each type in the list.6 optics-core%Append two type-level lists together.7 optics-coreCurry a type-level list.In pseudo (dependent-)Haskell: 7 xs y =  (->) y xs 8 optics-coreReverse a type-level list.> optics-coreSingleton index list? optics-core An alias for an empty index-list@ optics-core/A list of index types, used for indexed optics.E optics-coreIf the second list is empty, we can shortcircuit and pick the first list immediately.&'()*+,-./0123456789:;<=>?@@?>=<;:9876452301/.-,+*)('&  Safe-Inferred'(./059>?!I optics-core-Check if any leaf in the tree has a '[Path]'.J optics-coreGenerate bogus equality constraints that attempt to unify generic representations with this type in case there is an error such as missing field, constructor etc. so these huge types don't leak into error messages.K optics-coreCompute path to a constructor in a sum or a field in a product at a specific position.L optics-core0Compute paths to a field at a specific position.M optics-coreCompute path to a constructor in a sum or a field in a product with a specific name.N optics-core.Compute paths to a field with a specific name.R optics-coreA map that allows reaching a specific field in a generic representation of a data type. Computed up front by generic optics for early error reporting and efficient data traversal. HIJKLMNOPQRST RSTOPQNMLKJIH None'(./059>?$U optics-coreMapping tag types k to constraints on p.Using this type family we define the constraints that the various flavours of optics have to fulfill.V optics-coreTag for a review.W optics-coreTag for a reversed lens.X optics-coreTag for a fold.Y optics-coreTag for an affine fold.Z optics-coreTag for a getter.[ optics-coreTag for a reversed prism.\ optics-coreTag for a setter.] optics-coreTag for a traversal.^ optics-coreTag for an affine traversal._ optics-coreTag for a prism.` optics-coreTag for a lens.a optics-coreTag for an iso.b optics-core+Kind for types used as optic tags, such as `.UVWXYZ[\]^_`abba`_^]\[ZYXWVUNone'(./059>?(c optics-core3Computes the least upper bound of two optics kinds.In presence of a JoinKinds k l m constraint Optic m) represents the least upper bound of an Optic k and an Optic l3. This means in particular that composition of an Optic k and an Optic k will yield an Optic m.p optics-core/Subtyping relationship between kinds of optics.An instance of p k l means that any A k can be used as an A l. For example, we have an p ` ] instance, but not p ] `.This class needs instances for all possible combinations of tags.q optics-core&Witness of the subtyping relationship. optics-core*Every kind of optic can be used as itself. optics-core.Overlappable instance for a custom type error.cdefghijklmnopqpqonmlkjihgfecdNone'(./059>?1"  optics-core0Optic internally as a profunctor transformation. optics-core.Type representing the various kinds of optics.The tag parameter k# is translated into constraints on p via the type family U. optics-coreCommon special case of ) where source and target types are equal.Here, we need only one "big" and one "small" type. For lenses, this means that in the restricted form we cannot do type-changing updates. optics-core/Wrapper newtype for the whole family of optics.The first parameter k, identifies the particular optic kind (e.g. ` or ]).The parameter is is a list of types available as indices. This will typically be ? for unindexed optics, or > for optics with a single index. See the "Indexed optics" section of the overview documentation in the Optics module of the main optics package for more details.The parameters s and t) represent the "big" structure, whereas a and b! represent the "small" structure. optics-coreStrip the newtype wrapper off. optics-core0Explicit cast from one optic flavour to another.The resulting optic kind is given in the first type argument, so you can use TypeApplications to set it. For example   @` o turns o into a %B.This is the identity function, modulo some constraint jiggery-pokery. optics-core*Compose two optics of compatible flavours.Returns an optic of the appropriate supertype. If either or both optics are indexed, the composition preserves all the indices. optics-core'Compose two optics of the same flavour.Normally you can simply use () instead, but this may be useful to help type inference if the type of one of the optics is otherwise under-constrained. optics-coreFlipped function application, specialised to optics and binding tightly.1Useful for post-composing optics transformations:toListOf (ifolded %& ifiltered (\i s -> length s <= i)) ["", "a","abc"]["","a"]&'()*+,-./0123456789:;<=>?@UVWXYZ[\]^_`abcdefghijklmnopq 9 9 9 None'(059>?2 optics-coreInternal implementation of C.None'(./059>?5{ optics-coreGenerate sensible error messages in case a user tries to pass either an unindexed optic or indexed optic with unflattened indices where indexed optic with a single index is expected. optics-coreCheck whether a list of indices is not empty and generate sensible error message if it's not. optics-coreShow useful error message when a function expects optics without indices. optics-core2Index a traversal by position of visited elements. optics-coreConstruct a conjoined indexed optic that provides a separate code path when used without indices. Useful for defining indexed optics that are as efficient as their unindexed equivalents when used without indices.Note:  f g is well-defined if and only if f D D g.  None'(059>?8, optics-core Used for E and F. optics-core Used for G and H. optics-coreInternal implementation of I. optics-coreInternal implementation of J. optics-coreInternal implementation of K. optics-core Extract the  element. This will fairly eagerly determine that it can return ' the moment it sees any element at all. optics-core Extract the  element. This will fairly eagerly determine that it can return ' the moment it sees any element at all.  None'(059>?9I optics-coreInternal implementation of L. optics-coreInternal implementation of M. optics-coreInternal implementation of N.A function considered as an .None'(059>?; optics-coreType synonym for a getter. optics-core&View the value pointed to by a getter.If you want to  a type-modifying optic that is insufficiently polymorphic to be type-preserving, use -O. optics-core6View the function of the value pointed to by a getter. optics-coreBuild a getter from a function.ZZ Operators to  the type parameters of .None'(059>?< optics-coreLift  to the s parameter of an optic. optics-coreLift  to the t parameter of an optic. optics-coreLift  to the a parameter of an optic. optics-coreLift  to the b parameter of an optic.A P% that applies to at most one element.None'(059>?G8  optics-coreType synonym for a type-preserving van Laarhoven affine traversal. optics-coreType synonym for a type-modifying van Laarhoven affine traversal.Note: this isn't exactly van Laarhoven representation as there is no Pointed' class (which would be a superclass of  that contains  but not <). You can interpret the first argument as a dictionary of Pointed that supplies the point' function (i.e. the implementation of ).A Q has  available and hence can combine the effects arising from multiple elements using . In contrast, an  has no way to combine effects from multiple elements, so it must act on at most one element. (It can act on none at all thanks to the availability of point.) optics-core4Type synonym for a type-preserving affine traversal. optics-core3Type synonym for a type-modifying affine traversal. optics-core8Build an affine traversal from a matcher and an updater.If you want to build an - from the van Laarhoven representation, use . optics-core:Work with an affine traversal as a matcher and an updater. optics-coreBuild an affine traversal from the van Laarhoven representation.Example::{,azSnd = atraversalVL $ \point f ab@(a, b) -> if a >= 'a' && a <= 'z' then (a, ) <$> f b else point ab:}preview azSnd ('a', "Hi") Just "Hi"preview azSnd ('@', "Hi")Nothing!over azSnd (++ "!!!") ('f', "Hi") ('f',"Hi!!!")set azSnd "Bye" ('Y', "Hi") ('Y',"Hi") optics-coreTraverse over the target of an  and compute a -based answer. optics-core"Retrieve the value targeted by an  or return the original value while allowing the type to change if it does not match. R o D  ( )  .  o  optics-core?Filter result(s) of a traversal that don't satisfy a predicate.Note: This is not a legal P, unless you are very careful not to invalidate the predicate on the target.*As a counter example, consider that given evens =   the second P law is violated: 0S evens   TS evens   0S evens (  ) ,So, in order for this to qualify as a legal P you can only use it for actions that preserve the result of the predicate!For a safe variant see U (or V for read-only optics). ^ ^Optics for working with .None'(059>?Hc optics-coreAn  for working with a  of a  value. optics-coreAn  for working with a  of a  value.A W# that contains at most one element.None'(059>?Mr  optics-core Type synonym for an affine fold. optics-core Obtain an  by lifting  traverse_ like function.    D     D   optics-core"Retrieve the value targeted by an .5let _Right = prism Right $ either (Left . Left) Rightpreview _Right (Right 'x')Just 'x'preview _Right (Left 'y')Nothing optics-core0Retrieve a function of the value targeted by an . optics-coreTraverse over the target of an , computing a -based answer, but unlike X# do not construct a new structure. optics-core Create an  from a partial function.$preview (afolding listToMaybe) "foo"Just 'f' optics-core:Filter result(s) of a fold that don't satisfy a predicate. optics-coreTry the first -. If it returns no entry, try the second one.?preview (ix 1 % re _Left `afailing` ix 2 % re _Right) [0,1,2,3] Just (Left 1)preview (ix 42 % re _Left `afailing` ix 2 % re _Right) [0,1,2,3]Just (Right 2) optics-coreCheck to see if this  doesn't match.isn't _Just NothingTrue Y Y3None'(059>?N optics-coreInternal implementation of 0Y. None'(059>?N optics-coreInternal implementation of Z.!None'(059>?O optics-coreInternal implementation of [.None'(059>?RP optics-core Helper for \* family to visit the first fold only once. optics-core Helper for ] and the like for better efficiency than the foldr-based version.Note that the argument a" of the result should not be used. optics-core$Mark a value for evaluation to whnf.This allows us to, when applying a setter to a structure, evaluate only the parts that we modify. If an optic focuses on multiple targets, Applicative instance of Identity' makes sure that we force evaluation of all of them, but we leave anything else alone. optics-coreWrap the applicative action in - so that we know later that it was executed. optics-core7 with no lazy pattern matching for more efficient code.  #Extracts elements from a container.None'(059>?up) optics-coreType synonym for a fold. optics-core Obtain a  by lifting  like function.    D     D   optics-core-Combine the results of a fold using a monoid. optics-core!Fold via embedding into a monoid. optics-coreFold right-associatively. optics-core&Fold left-associatively, and strictly. optics-coreFold to a list.toListOf (_1 % folded % _Right) ([Right 'h', Left 5, Right 'i'], "bye")"hi" optics-core&Traverse over all of the targets of a , computing an -based answer, but unlike ^$ do not construct a new structure.  generalizes  to work over any .+traverseOf_ each putStrLn ("hello","world")helloworld  D    optics-core A version of  with the arguments flipped. optics-core2Evaluate each action in a structure observed by a + from left to right, ignoring the results.  D   4sequenceOf_ each (putStrLn "hello",putStrLn "world")helloworld optics-core Fold via the  class. optics-core Obtain a ( by lifting an operation that returns a  result.+This can be useful to lift operations from  Data.List and elsewhere into a .!toListOf (folding tail) [1,2,3,4][2,3,4] optics-core Obtain a  by lifting  like function.#toListOf (foldring foldr) [1,2,3,4] [1,2,3,4] optics-coreBuild a % that unfolds its values from a seed. _` D    toListOf (unfolded $ \b -> if b == 0 then Nothing else Just (b, b - 1)) 10[10,9,8,7,6,5,4,3,2,1] optics-coreConvert a fold to an 5 that visits the first element of the original fold.For the traversal version see a. optics-core.This allows you to traverse the elements of a  in the opposite order. optics-coreReturn entries of the first , then the second one.9toListOf (_1 % ix 0 `summing` _2 % ix 1) ([1,2], [4,7,1])[1,7]For the traversal version see b. optics-coreTry the first /. If it returns no entries, try the second one.$toListOf (ix 1 `failing` ix 0) [4,7][7]"toListOf (ix 1 `failing` ix 0) [4][4] optics-core5Check to see if this optic matches 1 or more entries.has _Left (Left 12)Truehas _Right (Left 12)FalseThis will always return  for a %B or c.has _1 ("hello","world")True optics-coreCheck to see if this  or P has no matches.hasn't _Left (Right 12)Truehasn't _Left (Left 12)False optics-coreRetrieve the first entry of a .headOf folded [1..10]Just 1headOf each (1,2)Just 1 optics-coreRetrieve the last entry of a .lastOf folded [1..10]Just 10lastOf each (1,2)Just 2 optics-coreReturns  if every target of a  is .andOf each (True, False)FalseandOf each (True, True)True  D    optics-coreReturns  if any target of a  is .orOf each (True, False)TrueorOf each (False, False)False  D    optics-coreReturns  if any target of a  satisfies a predicate.anyOf each (=='x') ('x','y')True optics-coreReturns  if every target of a  satisfies a predicate.allOf each (>=3) (4,5)TrueallOf folded (>=2) [1..10]False  D    optics-coreReturns  only if no targets of a  satisfy a predicate.;noneOf each (not . isn't _Nothing) (Just 3, Just 4, Just 5)True5noneOf (folded % folded) (<10) [[13,99,20],[3,71,42]]False optics-coreCalculate the  of every number targeted by a .productOf each (4,5)20productOf folded [1,2,3,4,5]120  D   This operation may be more strict than you would expect. If you want a lazier version use \o ->    o . optics-coreCalculate the  of every number targeted by a .sumOf each (5,6)11sumOf folded [1,2,3,4]10#sumOf (folded % each) [(1,2),(3,4)]10  D   This operation may be more strict than you would expect. If you want a lazier version use \o ->    o  optics-core#The sum of a collection of actions.asumOf each ("hello","world") "helloworld",asumOf each (Nothing, Just "hello", Nothing) Just "hello"  D    optics-core#The sum of a collection of actions.msumOf each ("hello","world") "helloworld",msumOf each (Nothing, Just "hello", Nothing) Just "hello"  D    optics-core/Does the element occur anywhere within a given  of the structure?%elemOf each "hello" ("hello","world")True  D    optics-core3Does the element not occur anywhere within a given  of the structure? notElemOf each 'd' ('a','b','c')True notElemOf each 'a' ('a','b','c')False  D    optics-core0Calculate the number of targets there are for a  in a given container.Note: This can be rather inefficient for large containers and just like -, this will not terminate for infinite folds.  D   lengthOf _1 ("hello",())1lengthOf folded [1..10]10.lengthOf (folded % folded) [[1,2],[3,4],[5,6]]6 optics-core2Obtain the maximum element (if any) targeted by a  safely.Note:  on a valid d, %B or c will always return  a value.maximumOf folded [1..10]Just 10maximumOf folded []Nothing2maximumOf (folded % filtered even) [1,4,3,6,7,9,2]Just 6  D ef ( "empty")    In the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> gh .  o gi- has lazier semantics but could leak memory. optics-core2Obtain the minimum element (if any) targeted by a  safely.Note:  on a valid d, %B or c will always return  a value.minimumOf folded [1..10]Just 1minimumOf folded []Nothing2minimumOf (folded % filtered even) [1,4,3,6,7,9,2]Just 2  D ef ( "empty")    In the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> gj .  o gk- has lazier semantics but could leak memory. optics-core2Obtain the maximum element (if any) targeted by a  according to a user supplied .maximumByOf folded (compare `on` length) ["mustard","relish","ham"]Just "mustard"In the interest of efficiency, This operation has semantics more strict than strictly necessary.  cmp D ef ( "empty")    cmp  optics-core2Obtain the minimum element (if any) targeted by a  according to a user supplied .In the interest of efficiency, This operation has semantics more strict than strictly necessary.minimumByOf folded (compare `on` length) ["mustard","relish","ham"] Just "ham"  cmp D ef ( "empty")    cmp  optics-coreThe  function takes a , a predicate and a structure and returns the leftmost element of the structure matching the predicate, or  if there is no such element.findOf each even (1,3,4,6)Just 4findOf folded even [1,3,5,7]Nothing  D    optics-coreThe  function takes a , a monadic predicate and a structure and returns in the monad the leftmost element of the structure matching the predicate, or  if there is no such element.findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6) "Checking 1" "Checking 3" "Checking 4"Just 4findMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7) "Checking 1" "Checking 3" "Checking 5" "Checking 7"Nothing   :: (Monad m, Foldable f) => (a -> m Bool) -> f a -> m (Maybe a)  optics-coreThe  function takes a , a key, and a structure containing key/value pairs. It returns the first value corresponding to the given key. This function generalizes  to work on an arbitrary  instead of lists.0lookupOf folded 4 [(2, 'a'), (4, 'b'), (4, 'c')]Just 'b'0lookupOf folded 2 [(2, 'a'), (4, 'b'), (4, 'c')]Just 'a'*X*X63"An indexed version of an .None'(059>?y optics-core(Type synonym for an indexed affine fold. optics-core Obtain an  by lifting  itraverse_ like function. aifoldVL   D   aitraverseOf_   D   optics-core7Retrieve the value along with its index targeted by an . optics-core?Retrieve a function of the value and its index targeted by an . optics-coreTraverse over the target of an , computing a -based answer, but unlike #l# do not construct a new structure. optics-core Create an  from a partial function. optics-coreObtain a potentially empty % by taking the element from another  and using it as an index. optics-coreTry the first -. If it returns no entry, try the second one. Y Y3#An indexed version of an m.None'(059>?  optics-coreType synonym for a type-preserving van Laarhoven indexed affine traversal. optics-coreType synonym for a type-modifying van Laarhoven indexed affine traversal.Note: this isn't exactly van Laarhoven representation as there is no Pointed' class (which would be a superclass of  that contains  but not <). You can interpret the first argument as a dictionary of Pointed that supplies the point' function (i.e. the implementation of ). optics-core? optics-core!Type synonym for an indexed fold. optics-core"Obtain an indexed fold by lifting  like function.    D     D   optics-core,Fold with index via embedding into a monoid. optics-core$Fold with index right-associatively. optics-core1Fold with index left-associatively, and strictly. optics-coreFold with index to a list.+itoListOf (folded % ifolded) ["abc", "def"]1[(0,'a'),(1,'b'),(2,'c'),(0,'d'),(1,'e'),(2,'f')]Note:5 currently indexed optics can be used as non-indexed.*toListOf (folded % ifolded) ["abc", "def"]"abcdef" optics-core'Traverse over all of the targets of an , computing an -based answer, but unlike r# do not construct a new structure.1itraverseOf_ each (curry print) ("hello","world") (0,"hello") (1,"world") optics-core A version of  with the arguments flipped. optics-coreIndexed fold via  class. optics-core Obtain an ) by lifting an operation that returns a  result.+This can be useful to lift operations from  Data.List and elsewhere into an .(itoListOf (ifolding words) "how are you"[(0,"how"),(1,"are"),(2,"you")] optics-core Obtain an  by lifting   like function.$itoListOf (ifoldring ifoldr) "hello")[(0,'h'),(1,'e'),(2,'l'),(3,'l'),(4,'o')] optics-coreConvert an indexed fold to an 5 that visits the first element of the original fold.For the traversal version see s. optics-coreFilter results of an  that don't satisfy a predicate.-toListOf (ifolded %& ifiltered (>)) [3,2,1,0][1,0] optics-core/This allows you to traverse the elements of an  in the opposite order. optics-coreReturn entries of the first , then the second one.?~ optics-core#Type synonym for an indexed getter. optics-core(Build an indexed getter from a function.iview (ito id) ('i', 'x') ('i','x') optics-coreUse a value itself as its own index. This is essentially an indexed version of u. optics-core/View the value pointed to by an indexed getter. optics-core?View the function of the value pointed to by an indexed getter.ZZAn indexed version of a %B.None'(059>?  optics-core>Type synonym for a type-preserving van Laarhoven indexed lens. optics-core=Type synonym for a type-modifying van Laarhoven indexed lens. optics-core0Type synonym for a type-preserving indexed lens. optics-core/Type synonym for a type-modifying indexed lens. optics-core1Build an indexed lens from a getter and a setter.If you want to build an - from the van Laarhoven representation, use . optics-coreWork with an indexed lens in the van Laarhoven representation. optics-coreFocus on both sides of an . optics-core0There is an indexed field for every type in the .set (mapped % devoid) 1 [][]!over (_Just % devoid) abs NothingNothing optics-coreIndexed _1' with other half of a pair as an index.See  for examples. optics-coreIndexed _2 with other half of a pair as an index. Specialized version of  itraversed to pairs, which can be .iview isnd ('a', True) ('a',True)That is not possible with  itraversed, because it is an  IxTraversal.0:t itraversed :: IxTraversal i (i, a) (i, b) a b-itraversed :: IxTraversal i (i, a) (i, b) a b$ :: IxTraversal i (i, a) (i, b) a b ` `An indexed version of a 0v.None'(/059>?V optics-core2Type synonym for a type-preserving indexed setter. optics-core1Type synonym for a type-modifying indexed setter. optics-core&Apply an indexed setter as a modifier. optics-core0Apply an indexed setter as a modifier, strictly. optics-coreApply an indexed setter.  o f D  o (i _ -> f i)  optics-core"Apply an indexed setter, strictly. optics-coreBuild an indexed setter from a function to modify the element(s). optics-coreIndexed setter via the   class.   D  \ \ %#A generalised or first-class field.None'(059>?  optics-core6Type synonym for a type-preserving van Laarhoven lens. optics-core5Type synonym for a type-modifying van Laarhoven lens. optics-core(Type synonym for a type-preserving lens. optics-core'Type synonym for a type-modifying lens. optics-coreBuild a lens from a getter and a setter, which must respect the well-formedness laws.If you want to build a - from the van Laarhoven representation, use . optics-core*Work with a lens as a getter and a setter.  ( f g) k D k f g  optics-core3Build a lens from the van Laarhoven representation. optics-core3Convert a lens to the van Laarhoven representation. optics-core5Work with a lens in the van Laarhoven representation. optics-coreStrict version of u.Useful for strictifying optics with lazy (irrefutable) pattern matching by precomposition, e.g. <w =  % <x  optics-coreMake a  from two other lenses by executing them on their respective halves of a product.0(Left 'a', Right 'b') ^. alongside chosen chosen ('a','b')<(Left 'a', Right 'b') & alongside chosen chosen .~ ('c','d')(Left 'c',Right 'd') optics-coreWe can always retrieve a () from any type.view united "hello"()set united () "hello""hello" ` `&Optics for working with s.None'(059>? optics-coreA  that focuses on the root of a .view root $ Node 42 []42 optics-coreA 3 returning the direct descendants of the root of a  y  D +Common abstraction for all kinds of optics.None'(059>?0457>?@bcpbpc@?>0745'Optics for working with s.None'(059>? optics-coreConstruct a map from an .%The construction is left-biased (see ), i.e. the first occurrences of keys in the fold or traversal order are preferred."toMapOf ifolded ["hello", "world"]"fromList [(0,"hello"),(1,"world")]8toMapOf (folded % ifolded) [('a',"alpha"),('b', "beta")]%fromList [('a',"alpha"),('b',"beta")],toMapOf (ifolded <%> ifolded) ["foo", "bar"]fromList [((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')]toMapOf (folded % ifolded) [('a', "hello"), ('b', "world"), ('a', "dummy")]&fromList [('a',"hello"),('b',"world")] optics-coreFocus on the largest key smaller than the given one and its corresponding value.Map.fromList [('a', "hi"), ('b', "there")] & over (lt 'b') (++ "!")$fromList [('a',"hi!"),('b',"there")]9ipreview (lt 'a') $ Map.fromList [('a', 'x'), ('b', 'y')]Nothing optics-coreFocus on the smallest key greater than the given one and its corresponding value.Map.fromList [('a', "hi"), ('b', "there")] & over (gt 'b') (++ "!")#fromList [('a',"hi"),('b',"there")]9ipreview (gt 'a') $ Map.fromList [('a', 'x'), ('b', 'y')]Just ('b','y') optics-coreFocus on the largest key smaller or equal than the given one and its corresponding value.Map.fromList [('a', "hi"), ('b', "there")] & over (le 'b') (++ "!")$fromList [('a',"hi"),('b',"there!")]9ipreview (le 'a') $ Map.fromList [('a', 'x'), ('b', 'y')]Just ('a','x') optics-coreFocus on the smallest key greater or equal than the given one and its corresponding value.Map.fromList [('a', "hi"), ('c', "there")] & over (ge 'b') (++ "!")$fromList [('a',"hi"),('c',"there!")]9ipreview (ge 'b') $ Map.fromList [('a', 'x'), ('c', 'y')]Just ('c','y')(None'(059>? optics-coreConstruct a map from an .%The construction is left-biased (see ), i.e. the first occurrences of keys in the fold or traversal order are preferred."toMapOf ifolded ["hello", "world"]"fromList [(0,"hello"),(1,"world")]4toMapOf (folded % ifolded) [(1,"alpha"),(2, "beta")]!fromList [(1,"alpha"),(2,"beta")]toMapOf (icompose (\a b -> 10*a+b) $ ifolded % ifolded) ["foo", "bar"]=fromList [(0,'f'),(1,'o'),(2,'o'),(10,'b'),(11,'a'),(12,'r')]toMapOf (folded % ifolded) [(1, "hello"), (2, "world"), (1, "dummy")]"fromList [(1,"hello"),(2,"world")] optics-coreFocus on the largest key smaller than the given one and its corresponding value.IntMap.fromList [(1, "hi"), (2, "there")] & over (lt 2) (++ "!") fromList [(1,"hi!"),(2,"there")]6ipreview (lt 1) $ IntMap.fromList [(1, 'x'), (2, 'y')]Nothing optics-coreFocus on the smallest key greater than the given one and its corresponding value.IntMap.fromList [(1, "hi"), (2, "there")] & over (gt 2) (++ "!")fromList [(1,"hi"),(2,"there")]6ipreview (gt 1) $ IntMap.fromList [(1, 'x'), (2, 'y')] Just (2,'y') optics-coreFocus on the largest key smaller or equal than the given one and its corresponding value.IntMap.fromList [(1, "hi"), (2, "there")] & over (le 2) (++ "!") fromList [(1,"hi"),(2,"there!")]6ipreview (le 1) $ IntMap.fromList [(1, 'x'), (2, 'y')] Just (1,'x') optics-coreFocus on the smallest key greater or equal than the given one and its corresponding value.IntMap.fromList [(1, "hi"), (3, "there")] & over (ge 2) (++ "!") fromList [(1,"hi"),(3,"there!")]6ipreview (ge 2) $ IntMap.fromList [(1, 'x'), (3, 'y')] Just (3,'y'))A generalised or first-class constructor.None'(059>?  optics-core)Type synonym for a type-preserving prism. optics-core(Type synonym for a type-modifying prism. optics-coreBuild a prism from a constructor and a matcher, which must respect the well-formedness laws.If you want to build a - from the van Laarhoven representation, use prismVL from the  optics-vl package. optics-core This is usually used to build a *, when you have to use an operation like z{ which already returns a . optics-core Work with a  as a constructor and a matcher. optics-coreUse a " to work over part of a structure. optics-core%Given a pair of prisms, project sums. Viewing a  as a co-%B-, this combinator can be seen to be dual to %|. optics-coreLift a  through a  functor, giving a  that matches only if all the elements of the container match the . optics-coreThis 0 compares for exact equality with a given value. only 4 # ()4 5 ^? only 4Nothing optics-coreThis  compares for approximate equality with a given value and a predicate for testing, an example where the value is the empty list and the predicate checks that a list is empty (same as }~ with the } list instance):nearly [] null # ()[][1,2,3,4] ^? nearly [] nullNothing  []  ::  [a] ()To comply with the " laws the arguments you supply to  nearly a p are somewhat constrained. We assume p x holds iff x D a.. Under that assumption then this is a valid .This is useful when working with a type where you can test equality for only a subset of its values, and the prism selects such a value. _ _) s for the  datatype.None'(059>?O optics-coreA  that matches on the  constructor of . optics-coreA  that matches on the  constructor of .*,Traversals for manipulating parts of a list.None'(059>? optics-coreA 0 stripping a prefix from a list when used as a P/, or prepending that prefix when run backwards:"preview" ^? prefixed "pre" Just "view""review" ^? prefixed "pre"Nothingprefixed "pre" # "amble" "preamble" optics-coreA 0 stripping a suffix from a list when used as a P., or appending that suffix when run backwards:"review" ^? suffixed "view" Just "re""review" ^? suffixed "tire"Nothingsuffixed ".o" # "hello" "hello.o"+ s for the  datatype.None'(059>? optics-coreA  that matches on the  constructor of . optics-coreA  that matches on the  constructor of .,The , operator allows some optics to be reversed.None'(/059>? optics-coreClass for optics that can be versed. optics-coreInjective type family that maps an optic kind to the optic kind produced by  versing it.  a = a  _ = [  [ = _  ` = W  W = `  Z = V  V = Z  optics-core Reverses optics, turning around d into d,  into  (and back), %B into   (and back) and c into   (and back).-?Converting read-write optics into their read-only counterparts.None'(./059>?9 optics-coreClass for read-write optics that have their read-only counterparts. optics-coreTurn read-write optic into its read-only counterpart (or leave read-only optics as-is). This is useful when you have an  optic ::  k is s t a b of read-write kind k such that s, t, a, b' are rigid, there is no evidence that s ~ t and a ~ b and you want to pass optic< to one of the functions that accept read-only optic kinds.Example:9let fstIntToChar = _1 :: Lens (Int, r) (Char, r) Int Char:t view fstIntToChar...(...Couldn't match type @Char@ with @Int@...:t view (getting fstIntToChar).view (getting fstIntToChar) :: (Int, r) -> Int  A backwards %B.None'(059>?$ optics-core1Type synonym for a type-preserving reversed lens. optics-core0Type synonym for a type-modifying reversed lens.WW A backwards .None'(059>? optics-core2Type synonym for a type-preserving reversed prism. optics-core1Type synonym for a type-modifying reversed prism.[[  A backwards c, i.e. a function.None'(059>?F optics-coreType synonym for a review. optics-core!Retrieve the value targeted by a .review _Left "hi" Left "hi" optics-coreAn analogue of  for reviews.VV1Translates between types with the same structure.None'(059>? optics-core-This class provides for symmetric bifunctors. optics-core    D   f   =    f  g   =    g  f g   =    g f view swapped (1,2)(2,1) optics-core'Type synonym for a type-preserving iso. optics-core&Type synonym for a type-modifying iso. optics-core.Build an iso from a pair of inverse functions.If you want to build an - from the van Laarhoven representation, use isoVL from the  optics-vl package. optics-core-Extract the two components of an isomorphism. optics-core Based on ala& from Conor McBride's work on Epigram.*This version is generalized to accept any  , not just a newtype.$au (coerced1 @Sum) foldMap [1,2,3,4]10You may want to think of this combinator as having the following, simpler type: au :: + s t a b -> ((b -> t) -> e -> s) -> e -> a  optics-coreThe opposite of working 0S a 0v is working  an isomorphism.  D 0S  ,  optics-core+Capture type constraints as an isomorphism.Note: This is the identity optic::t view equalityview equality :: a -> a optics-coreProof of reflexivity. optics-core? optics-coreClass for optics supporting  through a . optics-core>Type family that maps an optic to the optic kind produced by  using it. optics-coreThe % can be used to lift optic through a .  ::  s t a b ->  (f s) (g t) (f a) (g b)  :: %B s a ->  (f s) (f a)  ::  s a ->  (f s) (f a)  ::  t b ->  (g t) (g b)  ::  t b ->  (g t) (g b)  optics-core,[('a', True), ('b', False)] ^. _1 %& mapping"ab"let v = [[ (('a', True), "foo"), (('b', False), "bar")], [ (('c', True), "xyz") ] ]"v ^. _1 % _2 %& mapping %& mapping[[True,False],[True]]/A  for a type that may be .None&'(059>?6 optics-coreClass for types that may be . optics-coreisn't _Empty [1,2,3]True optics-core1Pattern synonym for matching on any type with an  instance.-case Nothing of { Empty -> True; _ -> False }True0*Applies an update to all contained values.None'(059>?  optics-core*Type synonym for a type-preserving setter. optics-core)Type synonym for a type-modifying setter. optics-coreApply a setter as a modifier. optics-core'Apply a setter as a modifier, strictly.2TODO DOC: what exactly is the strictness property?Example:  f :: Int -> (Int, a) -> (Int, a) f k acc | k > 0 = f (k - 1) $  <x (+1) acc | otherwise = acc runs in constant space, but would result in a space leak if used with .Note that replacing  with  or <x with <w5 (which amount to the same thing) doesn't help when  is used, because the first coordinate of a pair is never forced. optics-coreApply a setter.  o v D  o ( v) set _1 'x' ('y', 'z') ('x','z') optics-coreApply a setter, strictly.2TODO DOC: what exactly is the strictness property? optics-coreBuild a setter from a function to modify the element(s), which must respect the well-formedness laws. optics-core Create a  for a .   D  \ \1*Definitions of infix operators for optics.None'(059>?  optics-coreFlipped infix version of . optics-coreFlipped infix version of . optics-coreFlipped infix version of . optics-coreInfix version of . optics-coreInfix version of . optics-coreInfix version of . optics-coreInfix version of . optics-coreInfix version of . optics-coreSet the target of a  to  a value. o  b D  o ( b) Nothing & equality ?~ 'x'Just 'x'Map.empty & at 3 ?~ 'x'fromList [(3,'x')] optics-coreStrict version of ().   888844444421Definitions of unsafe infix operators for optics.None'(059>? optics-corePerform an *UNSAFE* - of an affine fold assuming that it is there.Left 4 ^?! _Left4"world" ^?! ix 3'l' [] ^?! _head'*** Exception: (^?!): empty affine fold...83 Optics for  and -like containers.None'(./059>? optics-core provides a  that can be used to read, write or delete the value associated with a key in a #-like container on an ad hoc basis.An instance of  should satisfy:  k D  k    optics-core"Map.fromList [(1,"world")] ^. at 1 Just "world"at 1 ?~ "hello" $ Map.emptyfromList [(1,"hello")]Note: Usage of this function might introduce space leaks if you're not careful to make sure that values put inside the  constructor are evaluated. To force the values and avoid such leaks, use  instead.Note: 6-like containers form a reasonable instance, but not Array)-like ones, where you cannot satisfy the  laws. optics-coreProvides a simple 2 lets you traverse the value at a given key in a 0 or element at an ordinal position in a list or . optics-coreType family that takes a key-value container type and returns the kind of optic to index into it. For most containers, it's ^,  Representable (Naperian) containers it is `, and multi-maps would have  A_Traversal. optics-coreNB: Setting the value of this  will only set the value in  if it is already present.!If you want to be able to insert missing values, you want .[1,2,3,4] & ix 2 %~ (*10) [1,2,30,4]"abcd" & ix 2 .~ 'e'"abed""abcd" ^? ix 2Just 'c' [] ^? ix 2Nothing optics-coreType family that takes a key-value container type and returns the type of values stored in the container, for example  ( k a) ~ a. This is shared by both  and . optics-coreThis class provides a simple  that lets you view (and modify) information about whether or not a container contains a given . Instances are provided for -like containers only. optics-core'IntSet.fromList [1,2,3,4] ^. contains 3True'IntSet.fromList [1,2,3,4] ^. contains 5False/IntSet.fromList [1,2,3,4] & contains 3 .~ FalsefromList [1,2,4] optics-coreType family that takes a key-value container type and returns the type of keys (indices) into the container, for example  ( k a) ~ k. This is shared by ,  and . optics-coreA definition of  for types with an  instance. This is the default if you don't specify a definition for . optics-core Version of  strict in the value inside the  constructor.Example:1(at () .~ Just (error "oops") $ Nothing) `seq` ()()2(at' () .~ Just (error "oops") $ Nothing) `seq` ()*** Exception: oops...+view (at ()) (Just $ error "oops") `seq` ()(),view (at' ()) (Just $ error "oops") `seq` ()*** Exception: oops...4It also works as expected for other data structures:2(at 1 .~ Just (error "oops") $ Map.empty) `seq` ()()3(at' 1 .~ Just (error "oops") $ Map.empty) `seq` ()*** Exception: oops... optics-core,Delete the value associated with a key in a -like container  k =  k 1 Nothing  optics-core  ::  ->  (a, a, a, a, a, a, a, a, a) a optics-core  ::  ->  (a, a, a, a, a, a, a, a) a optics-core  ::  ->  (a, a, a, a, a, a, a) a optics-core  ::  ->  (a, a, a, a, a, a) a optics-core  ::  ->  (a, a, a, a, a) a optics-core  ::  ->  (a, a, a, a) a optics-core  ::  ->  (a, a, a) a optics-core  ::  ->  (a, a) a optics-core arr  i D arr 1  i arr // [(i,e)] D  i 1 e  arr  optics-core arr  i D arr 1  i arr // [(i,e)] D  i 1 e  arr  4$Turn optics into arrow transformers.None'(059>? optics-core(Turn an optic into an arrow transformer. optics-coreRun an arrow command and use the output to set all the targets of an optic to the result. runKleisli action ((), (), ()) where action = assignA _1 (Kleisli (const getVal1)) >>> assignA _2 (Kleisli (const getVal2)) >>> assignA _3 (Kleisli (const getVal3)) getVal1 :: Either String Int getVal1 = ... getVal2 :: Either String Bool getVal2 = ... getVal3 :: Either String Char getVal3 = ...  has the type   (, , )5Optics for working with s.None'(059>? optics-coreThis % can be used to change the type of a ( by mapping the elements to new values. Sadly, you can't create a valid P for a ., but you can manipulate it by reading using  and reindexing it via .,over setmapped (+1) (Set.fromList [1,2,3,4])fromList [2,3,4,5] optics-coreConstruct a set from a fold.setOf folded ["hello","world"]fromList ["hello","world"]7setOf (folded % _2) [("hello",1),("world",2),("!!!",3)]fromList [1,2,3]6Optics for working with s.None'(059>? optics-core IntSet isn't Foldable, but this * can be used to access the members of an .&sumOf members $ setOf folded [1,2,3,4]10 optics-coreThis % can be used to change the type of a ( by mapping the elements to new values. Sadly, you can't create a valid P for an ., but you can manipulate it by reading using  and reindexing it via ./over setmapped (+1) (IntSet.fromList [1,2,3,4])fromList [2,3,4,5] optics-core Construct an  from a fold.setOf folded [1,2,3,4]fromList [1,2,3,4]7setOf (folded % _2) [("hello",1),("world",2),("!!!",3)]fromList [1,2,3]>Lifts an effectful operation on elements to act on structures.None'(/059>? optics-core;Type synonym for a type-preserving van Laarhoven traversal. optics-core:Type synonym for a type-modifying van Laarhoven traversal. optics-core-Type synonym for a type-preserving traversal. optics-core,Type synonym for a type-modifying traversal. optics-core8Build a traversal from the van Laarhoven representation.    D     D   optics-core.Map each element of a structure targeted by a , evaluate these actions from left to right, and collect the results. optics-core A version of  with the arguments flipped. optics-coreEvaluate each action in the structure from left to right, and collect the results.sequenceOf each ([1,2],[3,4])[(1,3),(1,4),(2,3),(2,4)]  D   D    o D  o   optics-coreThis generalizes  to an arbitrary .Note:  handles ragged inputs more intelligently, but for non-ragged inputs:'transposeOf traversed [[1,2,3],[4,5,6]][[1,4],[2,5],[3,6]]  D    optics-coreThis generalizes  to an arbitrary .  D    accumulates  from left to right. optics-coreThis generalizes  to an arbitrary .  D    accumulates  from right to left. optics-coreThis permits the use of  over an arbitrary .  D    optics-coreThis permits the use of  over an arbitrary .  D    optics-core Try to map a function over this 5, returning Nothing if the traversal has no targets.failover (element 3) (*2) [1,2]Nothingfailover _Left (*2) (Right 4)Nothingfailover _Right (*2) (Right 4)Just (Right 8) optics-core Version of  strict in the application of f. optics-core Construct a  via the  class.   =   optics-coreTraverse both parts of a  container with matching types.Note: for traversing a pair or an  it's better to use 7 and  respectively to reduce potential for bugs due to too much polymorphism.(1,2) & both %~ (*10)(10,20)"over both length ("hello","world")(5,5)foldOf both ("hello","world") "helloworld" optics-coreThis allows you to 4 the elements of a traversal in the opposite order. optics-core turns a  into a .Note: You should really try to maintain the invariant of the number of children in the list.-('a','b','c') & partsOf each .~ ['x','y','z'] ('x','y','z')Any extras will be lost. If you do not supply enough, then the remainder will come from the original structure.1('a','b','c') & partsOf each .~ ['w','x','y','z'] ('w','x','y'))('a','b','c') & partsOf each .~ ['x','y'] ('x','y','c')+('b', 'a', 'd', 'c') & partsOf each %~ sort('a','b','c','d')So technically, this is only a 8 if you do not change the number of results it returns. optics-coreConvert a traversal to an : that visits the first element of the original traversal.For the fold version see .!"foo" & singular traversed .~ 'z'"zoo" optics-core)Combine two disjoint traversals into one.over (_1 % _Just `adjoin` _2 % _Right) not (Just True, Right False)(Just False,Right True)Note: if the argument traversals are not disjoint, the result will not respect the  laws, because it will visit the same element multiple times. See section 7 of  >https://www.cs.ox.ac.uk/jeremy.gibbons/publications/uitbaf.pdf9Understanding Idiomatic Traversals Backwards and Forwards) by Bird et al. for why this is illegal.+view (partsOf (each `adjoin` _1)) ('x','y')"xyx"0set (partsOf (each `adjoin` _1)) "abc" ('x','y') ('c','b')For the  version see .]]6An indexed version of a .None'(/059>?! optics-coreType synonym for a type-preserving van Laarhoven indexed traversal. optics-coreType synonym for a type-modifying van Laarhoven indexed traversal. optics-core5Type synonym for a type-preserving indexed traversal. optics-core4Type synonym for a type-modifying indexed traversal. optics-coreBuild an indexed traversal from the van Laarhoven representation.    D     D   optics-core/Map each element of a structure targeted by an  (supplying the index), evaluate these actions from left to right, and collect the results.This yields the van Laarhoven representation of an indexed traversal. optics-core A version of  with the arguments flipped. optics-core Generalizes  to an arbitrary .& accumulates state from left to right.  o D  o    optics-core Generalizes  to an arbitrary .& accumulates state from right to left.  o D  o    optics-coreThis permits the use of  over an arbitrary . optics-coreThis permits the use of  over an arbitrary . optics-core5Try to map a function which uses the index over this  , returning  if the  has no targets. optics-core Version of + strict in the application of the function. optics-coreIndexed traversal via the  class.   D  2iover (itraversed <%> itraversed) (,) ["ab", "cd"]5[[((0,0),'a'),((0,1),'b')],[((1,0),'c'),((1,1),'d')]] optics-coreFilter results of an 0 that don't satisfy a predicate on the indices..toListOf (itraversed %& indices even) "foobar""foa" optics-coreThis allows you to = the elements of an indexed traversal in the opposite order. optics-core Traverse selected elements of a 2 where their ordinal positions match a predicate. optics-coreTraverse elements of a < container where their ordinal positions match a predicate.  D    optics-core Traverse the nth element of a  if it exists. optics-core Traverse the nth element of a  container.  D    optics-coreAn indexed version of : that receives the entire list of indices as its indices. optics-core#Convert an indexed traversal to an : that visits the first element of the original traversal.For the fold version see .*[1,2,3] & iover (isingular itraversed) (-)[-1,2,3] optics-core1Combine two disjoint indexed traversals into one.iover (_1 % itraversed `iadjoin` _2 % itraversed) (+) ([0, 0, 0], (3, 5))([0,1,2],(3,8))Note: if the argument traversals are not disjoint, the result will not respect the  laws, because it will visit the same element multiple times. See section 7 of  >https://www.cs.ox.ac.uk/jeremy.gibbons/publications/uitbaf.pdf9Understanding Idiomatic Traversals Backwards and Forwards) by Bird et al. for why this is illegal.0iview (ipartsOf (each `iadjoin` each)) ("x","y")([0,1,0,1],["x","y","x","y"])iset (ipartsOf (each `iadjoin` each)) (const ["a","b","c","d"]) ("x","y") ("c","d")For the  version see .]]67An ; for each element of a (potentially monomorphic) container.None'(059>?) optics-coreExtract 2 element of a (potentially monomorphic) container.over each (*10) (1,2,3) (10,20,30)*iover each (\i a -> a*10 + succ i) (1,2,3) (11,22,33) optics-core  ::  i =>  i ( i a) ( i b) a b optics-core  ::  [Int] ( a) ( b) a b optics-core  ::   ( a) ( b) a b optics-core  ::  () ( a) ( b) a b optics-core  ::  () ( a) ( b) a b optics-core  ::   (NonEmpty a) (NonEmpty b) a b optics-core  ::   [a] [b] a b optics-core  ::   ( a) ( b) a b optics-core  ::  k ( k a) ( k b) a b optics-core  :: ( a,  b) =>  (Either () ()) ( a) ( b) a b optics-core  ::  ( () ()) ( a a) ( b b) a b optics-core  ::   (a, a, a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b, b, b) a b optics-core  ::  = (a, a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b, b) a b optics-core  ::  7 (a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b) a b optics-core  ::  1 (a, a, a, a, a, a, a) (b, b, b, b, b, b, b) a b optics-core  ::  * (a, a, a, a, a, a) (b, b, b, b, b, b) a b optics-core  ::  $ (a, a, a, a, a) (b, b, b, b, b) a b optics-core  ::   (a, a, a, a) (b, b, b, b) a b optics-core  ::   (a, a, a) (b, b, b) a b optics-core  ::   (a, a) (b, b) a b8None'(/059>?, optics-core:Convert from the data type to its representation (or back)-view (generic % re generic) "hello" :: String"hello" optics-core:Convert from the data type to its representation (or back) optics-core+Only for a derived balanced representation. optics-core+Only for a derived balanced representation. optics-core+Only for a derived balanced representation. optics-coreMatching type. optics-core(Recurse into the inner type if it has a  instance.1HIJKLMNOPQRST$:Overloaded labels as optics.None'(-./059>?5 optics-coreIf the explicit-generic-labels Cabal flag is enabled, only types with this instance (which can be trivially derived with DeriveAnyClass extension) will be able to use labels as generic optics with a specific type.It's an option for application developers to disable implicit fallback to generic optics for more control.Libraries using generic labels with their data types should derive this instance for compatibility with the explicit-generic-labels flag.Note: the flag explicit-generic-labels is disabled by default. Enabling it is generally unsupported as it might lead to compilation errors of dependencies relying on implicit fallback to generic optics. optics-core=Type synonym for a type-preserving optic as overloaded label. optics-core(Support for overloaded labels as optics.An overloaded label #foo2 can be used as an optic if there is an instance  "foo" k s t a b.Alternatively, if both s and t have a  ( if explicit-generic-labels- flag is enabled) instance, a total field of s is accessible by a label #field of kind `&, whereas its constructor by a label  #_Constructor of kind _. optics-coreUsed to interpret overloaded label syntax. An overloaded label #foo corresponds to  @"foo". optics-coreIf for an overloaded label #label% there is no instance starting with LabelOptic "label" in scope, using it in the context of optics makes GHC immediately pick the overlappable instance defined below (since no other instance could match). If at this point GHC has no information about s or t,, it ends up picking incoherent instance of GenericLabelOptic defined below. Prevent that (if only to be able to inspect most polymorphic types of foo % bar or  view #foo in GHCi) by defining a dummy instance that matches all names, thus postponing instance resolution until s or t is known. optics-core#If no instance matches, try to use  machinery for field access.$For more information have a look at ; and ;.9Optics for types defined in  GHC.Generics.None'(059>?6p  $Core definitions for indexed optics.None'(/059>?=  optics-core,Class for optic kinds that can have indices. optics-core5Convert an indexed optic to its unindexed equivalent. optics-coreCompose two indexed optics. Their indices are composed as a pair..itoListOf (ifolded <%> ifolded) ["foo", "bar"][((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')] optics-coreCompose two indexed optics and drop indices of the left one. (If you want to compose a non-indexed and an indexed optic, you can just use ().)-itoListOf (ifolded %> ifolded) ["foo", "bar"]1[(0,'f'),(1,'o'),(2,'o'),(0,'b'),(1,'a'),(2,'r')] optics-coreCompose two indexed optics and drop indices of the right one. (If you want to compose an indexed and a non-indexed optic, you can just use ().)-itoListOf (ifolded <% ifolded) ["foo", "bar"]1[(0,'f'),(0,'o'),(0,'o'),(1,'b'),(1,'a'),(1,'r')] optics-coreRemap the index.(itoListOf (reindexed succ ifolded) "foo"[(1,'f'),(2,'o'),(3,'o')]+itoListOf (ifolded %& reindexed succ) "foo"[(1,'f'),(2,'o'),(3,'o')] optics-core1Flatten indices obtained from two indexed optics.;itoListOf (ifolded % ifolded %& icompose (,)) ["foo","bar"][((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')] optics-core3Flatten indices obtained from three indexed optics.itoListOf (ifolded % ifolded % ifolded %& icompose3 (,,)) [["foo","bar"],["xyz"]][((0,0,0),'f'),((0,0,1),'o'),((0,0,2),'o'),((0,1,0),'b'),((0,1,1),'a'),((0,1,2),'r'),((1,0,0),'x'),((1,0,1),'y'),((1,0,2),'z')] optics-core2Flatten indices obtained from four indexed optics. optics-core2Flatten indices obtained from five indexed optics. optics-coreFlatten indices obtained from arbitrary number of indexed optics.  XYZ\]^`  9 9 9 ;Data access via the  type class.None'(-/059>?Q  optics-coreTraverse occurrences of a type a within a type s using its  instance.8toListOf (gplate @Char) ('h', ((), 'e', Just 'l'), "lo")"hello"If a occurs recursively in its own definition, only outermost occurrences of a within s will be traversed:'toListOf (gplate @String) ("one","two") ["one","two"]Note: types without a  instance in scope when  class constraint is resolved will not be entered during the traversal.)let noG = (NoG 'n', (Just 'i', "c"), 'e')toListOf (gplate @Char) noG"ice"deriving instance Generic NoGtoListOf (gplate @Char) noG"nice" optics-coreFocus on a constructor name of a type s using its  instance.:{0data Animal = Dog { name :: String, age :: Int }3 | Cat { name :: String, purrs :: Bool } deriving (Show, Generic):}let dog = Dog "Sparky" 2let cat = Cat "Cuddly" Truedog ^? gconstructor @"Dog"Just ("Sparky",2)dog ^? gconstructor @"Cat"Nothing%cat & gconstructor @"Cat" % _2 %~ not$Cat {name = "Cuddly", purrs = False})dog & gconstructor @"Cat" % _1 .~ "Merry"Dog {name = "Sparky", age = 2}cat ^? gconstructor @"Parrot"...:...Type @Animal@ doesn't have a constructor named @Parrot@ ...In the......Types without a  instance are not supported:NoG 'x' ^. gconstructor @"NoG"...-...Type @NoG@ doesn't have a Generic instance ...In the......Note:  is supported by :, and can be used with a concise syntax via OverloadedLabels. dog ^? #_DogJust ("Sparky",2)cat & #_Cat % _1 .~ "Merry""Cat {name = "Merry", purrs = True} optics-coreFocus on a field at position n of type a within a type s using its  instance.('a', 'b', 'c') ^. gposition @2'b';('a', 'b') & gposition @1 .~ "hi" & gposition @2 .~ "there"("hi","there")('a', 'b', 'c') ^. gposition @4...6...Data constructor @(,,)@ has 3 fields, 4th requested ...In the......() ^. gposition @1...5...Data constructor @()@ has no fields, 1st requested ...In the......Types without a  instance are not supported:NoG 'x' ^. gposition @1...-...Type @NoG@ doesn't have a Generic instance ...In the......Note: Positions start from 1:('a', 'b') ^. gposition @0......There is no 0th position ...In the...... optics-core"Focus on a possibly partial field name of type a within a type s using its  instance.:{&data Fish = Herring { name :: String }8 | Tuna { name :: String, sleeping :: Bool } deriving Generic:}(let herring = Herring { name = "Henry" }5let tuna = Tuna { name = "Tony", sleeping = True }herring ^? gafield @"name" Just "Henry"herring ^? gafield @"sleeping"Nothingtuna ^? gafield @"sleeping" Just TrueTypes without a  instance are not supported:NoG 'x' ^? gafield @"any"...-...Type @NoG@ doesn't have a Generic instance ...In the......Note: trying to access a field that doesn't exist in any data constructor results in an error:tuna ^? gafield @"salary"...2...Type @Fish@ doesn't have a field named @salary@ ...In the...... optics-coreFocus on a field name of type a within a type s using its  instance.:{ data User a = User { name :: String , age :: a } | LazyUser { name :: String , age :: a , lazy :: Bool } deriving (Show, Generic):}$let user = User "Tom" 32 :: User Intuser ^. gfield @"name""Tom"user ^. gfield @"age"32user ^. gfield @"salary"...>...Data constructor @User@ doesn't have a field named @salary@ ...In the......7Only total fields are accessible (for partial ones see ):user ^. gfield @"lazy"...<...Data constructor @User@ doesn't have a field named @lazy@ ...In the......$Type changing updates are supported:user & gfield @"age" .~ ()User {name = "Tom", age = ()}Types without a  instance are not supported:NoG 'x' ^. gfield @"any"...-...Type @NoG@ doesn't have a Generic instance ...In the......Note:  is supported by :, and can be used with a concise syntax via OverloadedLabels. user ^. #name"Tom"user & #age %~ (+1)User {name = "Tom", age = 33} optics-coreHidden instance. optics-coreHidden instance. optics-coreHidden instance. optics-coreHidden instance. optics-coreHidden instance. optics-coreHidden instance.  <es for tuple types.None'(/059>?YJ optics-core,Provides access to the 9th field of a tuple. optics-core Access the 9th field of a tuple. optics-core+Provide access to the 8th field of a tuple. optics-core Access the 8th field of a tuple. optics-core+Provide access to the 7th field of a tuple. optics-core Access the 7th field of a tuple. optics-core.Provides access to the 6th element of a tuple. optics-core Access the 6th field of a tuple. optics-core,Provides access to the 5th field of a tuple. optics-core Access the 5th field of a tuple. optics-core+Provide access to the 4th field of a tuple. optics-core Access the 4th field of a tuple. optics-core,Provides access to the 3rd field of a tuple. optics-core Access the 3rd field of a tuple. optics-core,Provides access to the 2nd field of a tuple. optics-core Access the 2nd field of a tuple._2 .~ "hello" $ (1,(),3,4)(1,"hello",3,4)(1,2,3,4) & _2 %~ (*3) (1,6,3,4)traverseOf _2 print (1,2)2(1,()) optics-core(Provides access to 1st field of a tuple. optics-core?Access the 1st field of a tuple (and possibly change its type). (1,2) ^. _11(1,2) & _1 .~ "hello" ("hello",2)(traverseOf _1 putStrLn ("hello","world")hello ((),"world")/This can also be used on larger tuples as well:(1,2,3,4,5) & _1 %~ (+41) (42,2,3,4,5) optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of  optics-coreStrict version of =:Optics to access the left or right element of a container.None&'(059>?f optics-coreThis class provides a way to attach or detach elements on the right side of a structure in a flexible manner. optics-coreThis class provides a way to attach or detach elements on the left side of a structure in a flexible manner. optics-core  ::  [a] [b] (a, [a]) (b, [b])  ::  ( a) ( b) (a,  a) (b,  b)  :: 3 (Vector a) (Vector b) (a, Vector a) (b, Vector b)  ::   (, )  ::  Text (, Text)  ::  ByteString (, ByteString)  optics-corePattern synonym for matching on the rightmost element of a structure.#case ['a','b','c'] of (_ :> x) -> x'c' optics-corePattern synonym for matching on the leftmost element of a structure.#case ['a','b','c'] of (x :< _) -> x'a' optics-core an element onto a container.This is an infix alias for .1 <| [][1] 'a' <| "bc""abc"1 <| [][1] 1 <| [2, 3][1,2,3] optics-core an element onto a container. cons 'a' """a" cons 'a' "bc""abc" optics-coreAttempt to extract the left-most element from a container, and a version of the container without that element. uncons []Nothinguncons [1, 2, 3]Just (1,[2,3]) optics-coreAn  reading and writing to the  of a  non-empty container."abc" ^? _headJust 'a'"abc" & _head .~ 'd'"dbc"[1,2,3] & _head %~ (*10)[10,2,3][] & _head %~ absurd[][1,2,3] ^? _headJust 1 [] ^? _headNothing[1,2] ^? _headJust 1[] & _head .~ 1[][0] & _head .~ 2[2][0,1] & _head .~ 2[2,1] optics-coreAn  reading and writing to the  of a  non-empty container."ab" & _tail .~ "cde""acde"[] & _tail .~ [1,2][]([1,2,3,4,5] & _tail % traversed %~ (*10)[1,20,30,40,50][1,2] & _tail .~ [3,4,5] [1,3,4,5][] & _tail .~ [1,2][]"abc" ^? _tail Just "bc""hello" ^? _tail Just "ello" "" ^? _tailNothing optics-coreAn 8 reading and replacing all but the a last element of a  non-empty container."abcd" ^? _init Just "abc" "" ^? _initNothing"ab" & _init .~ "cde""cdeb"[] & _init .~ [1,2][]&[1,2,3,4] & _init % traversed %~ (*10) [10,20,30,4][1,2,3] ^? _init Just [1,2]"hello" ^? _init Just "hell" [] ^? _initNothing optics-coreAn / reading and writing to the last element of a  non-empty container."abc" ^? _lastJust 'c' "" ^? _lastNothing[1,2,3] & _last %~ (+1)[1,2,4][1,2] ^? _lastJust 2[] & _last .~ 1[][0] & _last .~ 2[2][0,1] & _last .~ 2[0,2] optics-core( an element onto the end of a container.This is an infix alias for . "" |> 'a'"a" "bc" |> 'a'"bca" optics-core( an element onto the end of a container.snoc "hello" '!'"hello!" optics-coreAttempt to extract the right-most element from a container, and a version of the container without that element.unsnoc "hello!"Just ("hello",'!') unsnoc ""Nothing555555>&Optics for working with numeric types.None&'(059>?m  optics-corePattern synonym that can be used to construct or pattern match on an  as if it were of any  type. optics-coreThis * can be used to model the fact that every  type is a subset of .Embedding through the  only succeeds if the 2 would pass through unmodified when re-extracted. optics-core?A prism that shows and reads integers in base-2 through base-36Note: This is an improper prism, since leading 0s are stripped when reading."100" ^? base 16Just 256 1767707668033969 ^. re (base 36) "helloworld" optics-core  =  2 optics-core  =  8 optics-core  =  10 optics-core  =  16 optics-core  n =  (+n) (subtract n)"[1..3] ^.. traversed % adding 1000[1001,1002,1003] optics-core  n =  (subtract n) ((+n)  n = , ( n)  optics-core  n = iso (*n) (/n)Note: This errors for n = 05 & multiplying 1000 %~ (+3)5.003let fahrenheit = multiplying (9/5) % adding 32 in 230 ^. re fahrenheit110.0 optics-core   n =  (/n) (*n)  n = , ( n)Note: This errors for n = 0 optics-core  n =  (**n) (**recip n)Note: This errors for n = 0au (coerced1 @Sum % re (exponentiating 2)) (foldMapOf each) (3,4) == 5True optics-core  =   8au (coerced1 @Sum % negated) (foldMapOf each) (3,4) == 7True;au (coerced1 @Sum) (foldMapOf (each % negated)) (3,4) == -7True  *The core optics functionality re-exported.None'(059>?n  0457>?@VWXYZ[\]^_`abcp?Optics for working with s.None'(059>?w optics-coreA  is isomorphic to a  viewl m D m 1 Seq.fromList [1,2,3] ^. viewL1 :< fromList [2,3]Seq.empty ^. viewLEmptyLEmptyL ^. re viewL fromList []*review viewL $ 1 Seq.:< Seq.fromList [2,3]fromList [1,2,3] optics-coreA  is isomorphic to a  viewr m D m 1 Seq.fromList [1,2,3] ^. viewRfromList [1,2] :> 3Seq.empty ^. viewREmptyREmptyR ^. re viewR fromList []*review viewR $ Seq.fromList [1,2] Seq.:> 3fromList [1,2,3] optics-coreTraverse the first n elements of a 'Seq.fromList [1,2,3,4,5] ^.. slicedTo 2[1,2].Seq.fromList [1,2,3,4,5] & slicedTo 2 %~ (*10)fromList [10,20,3,4,5]+Seq.fromList [1,2,4,5,6] & slicedTo 10 .~ 0fromList [0,0,0,0,0] optics-coreTraverse all but the first n elements of a )Seq.fromList [1,2,3,4,5] ^.. slicedFrom 2[3,4,5]0Seq.fromList [1,2,3,4,5] & slicedFrom 2 %~ (*10)fromList [1,2,30,40,50]-Seq.fromList [1,2,3,4,5] & slicedFrom 10 .~ 0fromList [1,2,3,4,5] optics-core(Traverse all the elements numbered from i to j of a .Seq.fromList [1,2,3,4,5] & sliced 1 3 %~ (*10)fromList [1,20,30,4,5]'Seq.fromList [1,2,3,4,5] ^.. sliced 1 3[2,3]*Seq.fromList [1,2,3,4,5] & sliced 1 3 .~ 0fromList [1,0,0,4,5] optics-core Construct a  from a fold.seqOf folded ["hello","world"]fromList ["hello","world"]7seqOf (folded % _2) [("hello",1),("world",2),("!!!",3)]fromList [1,2,3]                                                             AAcymXoRV !WI]JK\GE"q"""""""#######l##pLMNHF$$$$$C%%%%B%%%%%%%|%&&'''''((((())**++,,,,,,,,,,,,,,,,,---O---------     du..........//~/////////////////////00v0S00000Y111111111123333333333333333333333333333333333333333444444444444455666QP^[abnrZUst7777777777777777777777888888888888888888888888888888888888888888888888888888888888888888888888888888888888::::::::::D;;;;;;;;;;;;;;;;;;;;;<<<<<<<<<<<<<<<<<<x<w<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<<======================>>>>>>>>>>>>>??????z{z                      3  3 3 3 3 3 3 3                              &optics-core-0.4-LvtBa7lrhQQ5XGfQmCGebV Optics.OpticOptics.Internal.UtilsOptics.Indexed.CoreOptics.IxSetter Optics.IxFoldOptics.IxTraversalOptics.Internal.BiOptics.Internal.MagicOptics.Internal.Optic.TypeLevel!Optics.Internal.Generic.TypeLevelOptics.Internal.Optic.Types Optics.ReviewOptics.ReversedLens Optics.FoldOptics.AffineFold Optics.GetterOptics.ReversedPrismOptics.TraversalOptics.AffineTraversal Optics.Prism Optics.IxLens Optics.IsoOptics.Internal.Optic.SubtypingOptics.Internal.OpticOptics.Internal.IxSetterOptics.Internal.IndexedOptics.Internal.FoldOptics.Internal.IxFold Optics.CoerceData.Typeable.OpticsOptics.Internal.SetterOptics.Internal.IxTraversalOptics.Internal.TraversalOptics.IxAffineFoldOptics.IxAffineTraversalOptics.IxGetter Optics.LensData.Tree.OpticsData.Map.OpticsData.IntMap.OpticsData.Maybe.OpticsData.List.OpticsData.Either.Optics Optics.ReOptics.ReadOnlyOptics.MappingOptics.Empty.Core Optics.SetterOptics.OperatorsOptics.Operators.UnsafeOptics.At.Core Optics.ArrowData.Set.OpticsData.IntSet.OpticsOptics.Each.CoreOptics.Internal.GenericGHC.Generics.Optics Optics.LabelOptics.GenericData.Tuple.OpticsOptics.Cons.CoreNumeric.OpticsData.Sequence.OpticsOptics.Internal.Indexed.ClassesOpticLensimappednoIxlastOfilastOfheadOfiheadOffoldVLfoldedfoldringifoldVLifolded ifoldringgetting Traversal TraversalVLpreviewoverOpticsindicesfilteredFold atraverseOfmapped itraversed traversedfailing traverseOf_ traverseOfPreludeunfoldrsingularadjoinGetterIso Data.Maybe fromMaybeData.SemigroupgetMaxMaxgetMinMin iatraverseOfAffineTraversal IxTraversalunsafeFilteredIxFold IxAffineFold itraverseOf isingulariadjoinequalitySetter_1'_1view Data.Typeablecast alongside Optics.Empty_EmptyAsEmptyPrism ReversedPrism ReversedLensReviewtoreData.MapMap Control.Monadjoin.~^. Data.List transposeData.Traversable mapAccumL mapAccumReachchosengfield gconstructor labelOptic Data.WordWord8 Optics.Corebase Data.Function& Data.Functor<&>.indexed-profunctors-0.1-G2xyUs8t16g9eLVmVekckXData.Profunctor.Indexed.##.0indexed-traversable-0.1.1-Dw8MIJyvCj8IZQDXOa8TBpData.Foldable.WithIndexitoListifor_ itraverse_Data.Traversable.WithIndexifor WithIndeximapFunctorWithIndexifoldl'ifoldr'ifoldlifoldr ifoldMap'ifoldMapFoldableWithIndex itraverseTraversableWithIndexBicontravariant contrabimap contrafirst contrasecond Bifunctorbimapfirstsecondlphantomrphantom$fBifunctorTagged$fBicontravariantIxForgetM$fBicontravariantIxForget$fBicontravariantForgetM$fBicontravariantForgetTypeInferenceLoop Dysfunctional2$fTypeInferenceLoopkkkkkkkkkmsg1msg2msg3fieldkstab$fDysfunctionalkkkkkkfieldkstab HasShapeOf ToOrdinal QuoteSymbol QuoteTypeDefinedUnlessWhenIsLeft FromRight FirstRight AppendIndices appendIndicesIxEq CurryComposecomposeNAppendCurryReverseShowEliminationsAppendEliminations ShowOperatorsShowSymbolsWithOriginShowSymbolWithOriginWithIxNoIxIxList$fCurryCompose:$fCurryCompose[]$fAppendIndices:ys:$fAppendIndices[]ysys$fAppendIndicesxs[]xs$fHasShapeOfkab$fHasShapeOfkfagNoGenericError AnyHasPathHideRepsGetPositionPathGetPositionPaths GetNamePath GetFieldPathsPathPathLeft PathRightPathTreePathLeaf ConstraintsA_ReviewA_ReversedLensA_Fold An_AffineFoldA_GetterA_ReversedPrismA_Setter A_TraversalAn_AffineTraversalA_PrismA_LensAn_Iso OpticKind JoinKinds joinKindsTraversalEliminationsSetterEliminationsReviewEliminationsPrismEliminationsLensEliminationsIsoEliminationsGetterEliminationsFoldEliminationsAffineTraversalEliminationsAffineFoldEliminationsEliminationFormsIsimplies$fIsA_TraversalA_Setter$fIsA_TraversalA_Fold$fIsAn_AffineFoldA_Fold$fIsAn_AffineTraversalA_Setter$fIsAn_AffineTraversalA_Fold!$fIsAn_AffineTraversalA_Traversal#$fIsAn_AffineTraversalAn_AffineFold$fIsA_GetterA_Fold$fIsA_GetterAn_AffineFold$fIsA_LensA_Setter$fIsA_LensA_Fold$fIsA_LensA_Traversal$fIsA_LensAn_AffineFold$fIsA_LensAn_AffineTraversal$fIsA_LensA_Getter$fIsA_PrismA_Setter$fIsA_PrismA_Fold$fIsA_PrismA_Traversal$fIsA_PrismAn_AffineFold$fIsA_PrismAn_AffineTraversal$fIsA_PrismA_Review$fIsA_ReversedPrismA_Fold $fIsA_ReversedPrismAn_AffineFold$fIsA_ReversedPrismA_Getter$fIsA_ReversedLensA_Review$fIsAn_IsoA_Setter$fIsAn_IsoA_Fold$fIsAn_IsoA_Traversal$fIsAn_IsoAn_AffineFold$fIsAn_IsoAn_AffineTraversal$fIsAn_IsoA_Getter$fIsAn_IsoA_Lens$fIsAn_IsoA_Review$fIsAn_IsoA_Prism$fIsAn_IsoA_ReversedPrism$fIsAn_IsoA_ReversedLens$fIskk$fIskl$fJoinKindsklm&$fJoinKindsA_SetterA_TraversalA_Setter-$fJoinKindsA_SetterAn_AffineTraversalA_Setter!$fJoinKindsA_SetterA_LensA_Setter"$fJoinKindsA_SetterA_PrismA_Setter!$fJoinKindsA_SetterAn_IsoA_Setter#$fJoinKindsA_SetterA_SetterA_Setter"$fJoinKindsA_FoldA_TraversalA_Fold$$fJoinKindsA_FoldAn_AffineFoldA_Fold)$fJoinKindsA_FoldAn_AffineTraversalA_Fold$fJoinKindsA_FoldA_GetterA_Fold$fJoinKindsA_FoldA_LensA_Fold$fJoinKindsA_FoldA_PrismA_Fold&$fJoinKindsA_FoldA_ReversedPrismA_Fold$fJoinKindsA_FoldAn_IsoA_Fold$fJoinKindsA_FoldA_FoldA_Fold&$fJoinKindsA_TraversalA_SetterA_Setter"$fJoinKindsA_TraversalA_FoldA_Fold)$fJoinKindsA_TraversalAn_AffineFoldA_Fold3$fJoinKindsA_TraversalAn_AffineTraversalA_Traversal$$fJoinKindsA_TraversalA_GetterA_Fold'$fJoinKindsA_TraversalA_LensA_Traversal($fJoinKindsA_TraversalA_PrismA_Traversal+$fJoinKindsA_TraversalA_ReversedPrismA_Fold'$fJoinKindsA_TraversalAn_IsoA_Traversal,$fJoinKindsA_TraversalA_TraversalA_Traversal$$fJoinKindsAn_AffineFoldA_FoldA_Fold)$fJoinKindsAn_AffineFoldA_TraversalA_Fold7$fJoinKindsAn_AffineFoldAn_AffineTraversalAn_AffineFold-$fJoinKindsAn_AffineFoldA_GetterAn_AffineFold+$fJoinKindsAn_AffineFoldA_LensAn_AffineFold,$fJoinKindsAn_AffineFoldA_PrismAn_AffineFold4$fJoinKindsAn_AffineFoldA_ReversedPrismAn_AffineFold+$fJoinKindsAn_AffineFoldAn_IsoAn_AffineFold2$fJoinKindsAn_AffineFoldAn_AffineFoldAn_AffineFold-$fJoinKindsAn_AffineTraversalA_SetterA_Setter)$fJoinKindsAn_AffineTraversalA_FoldA_Fold3$fJoinKindsAn_AffineTraversalA_TraversalA_Traversal7$fJoinKindsAn_AffineTraversalAn_AffineFoldAn_AffineFold2$fJoinKindsAn_AffineTraversalA_GetterAn_AffineFold5$fJoinKindsAn_AffineTraversalA_LensAn_AffineTraversal6$fJoinKindsAn_AffineTraversalA_PrismAn_AffineTraversal9$fJoinKindsAn_AffineTraversalA_ReversedPrismAn_AffineFold5$fJoinKindsAn_AffineTraversalAn_IsoAn_AffineTraversal$fJoinKindsAn_AffineTraversalAn_AffineTraversalAn_AffineTraversal$fJoinKindsA_GetterA_FoldA_Fold$$fJoinKindsA_GetterA_TraversalA_Fold-$fJoinKindsA_GetterAn_AffineFoldAn_AffineFold2$fJoinKindsA_GetterAn_AffineTraversalAn_AffineFold!$fJoinKindsA_GetterA_LensA_Getter'$fJoinKindsA_GetterA_PrismAn_AffineFold*$fJoinKindsA_GetterA_ReversedPrismA_Getter!$fJoinKindsA_GetterAn_IsoA_Getter#$fJoinKindsA_GetterA_GetterA_Getter!$fJoinKindsA_LensA_SetterA_Setter$fJoinKindsA_LensA_FoldA_Fold'$fJoinKindsA_LensA_TraversalA_Traversal+$fJoinKindsA_LensAn_AffineFoldAn_AffineFold5$fJoinKindsA_LensAn_AffineTraversalAn_AffineTraversal!$fJoinKindsA_LensA_GetterA_Getter*$fJoinKindsA_LensA_PrismAn_AffineTraversal($fJoinKindsA_LensA_ReversedPrismA_Getter$fJoinKindsA_LensAn_IsoA_Lens$fJoinKindsA_LensA_LensA_Lens"$fJoinKindsA_ReviewA_PrismA_Review)$fJoinKindsA_ReviewA_ReversedLensA_Review!$fJoinKindsA_ReviewAn_IsoA_Review#$fJoinKindsA_ReviewA_ReviewA_Review"$fJoinKindsA_PrismA_SetterA_Setter$fJoinKindsA_PrismA_FoldA_Fold($fJoinKindsA_PrismA_TraversalA_Traversal,$fJoinKindsA_PrismAn_AffineFoldAn_AffineFold6$fJoinKindsA_PrismAn_AffineTraversalAn_AffineTraversal'$fJoinKindsA_PrismA_GetterAn_AffineFold*$fJoinKindsA_PrismA_LensAn_AffineTraversal"$fJoinKindsA_PrismA_ReviewA_Review.$fJoinKindsA_PrismA_ReversedPrismAn_AffineFold($fJoinKindsA_PrismA_ReversedLensA_Review$fJoinKindsA_PrismAn_IsoA_Prism $fJoinKindsA_PrismA_PrismA_Prism&$fJoinKindsA_ReversedPrismA_FoldA_Fold+$fJoinKindsA_ReversedPrismA_TraversalA_Fold4$fJoinKindsA_ReversedPrismAn_AffineFoldAn_AffineFold9$fJoinKindsA_ReversedPrismAn_AffineTraversalAn_AffineFold*$fJoinKindsA_ReversedPrismA_GetterA_Getter($fJoinKindsA_ReversedPrismA_LensA_Getter.$fJoinKindsA_ReversedPrismA_PrismAn_AffineFold/$fJoinKindsA_ReversedPrismAn_IsoA_ReversedPrism8$fJoinKindsA_ReversedPrismA_ReversedPrismA_ReversedPrism)$fJoinKindsA_ReversedLensA_ReviewA_Review($fJoinKindsA_ReversedLensA_PrismA_Review-$fJoinKindsA_ReversedLensAn_IsoA_ReversedLens5$fJoinKindsA_ReversedLensA_ReversedLensA_ReversedLens!$fJoinKindsAn_IsoA_SetterA_Setter$fJoinKindsAn_IsoA_FoldA_Fold'$fJoinKindsAn_IsoA_TraversalA_Traversal+$fJoinKindsAn_IsoAn_AffineFoldAn_AffineFold5$fJoinKindsAn_IsoAn_AffineTraversalAn_AffineTraversal!$fJoinKindsAn_IsoA_GetterA_Getter$fJoinKindsAn_IsoA_LensA_Lens!$fJoinKindsAn_IsoA_ReviewA_Review$fJoinKindsAn_IsoA_PrismA_Prism/$fJoinKindsAn_IsoA_ReversedPrismA_ReversedPrism-$fJoinKindsAn_IsoA_ReversedLensA_ReversedLens$fJoinKindsAn_IsoAn_IsoAn_IsoOptic__Optic_Optic'getOptic castOptic%%%%& imapped__Indexing runIndexingIntT ShowTypesHasSingleIndexNonEmptyIndicesAcceptsEmptyIndicesunIntTindexing conjoined$fAcceptsEmptyIndicesf[]$fAcceptsEmptyIndicesf:$fNonEmptyIndices:$fNonEmptyIndices[]$fHasSingleIndex[]i$fHasSingleIndex:i$fHasSingleIndex:i0$fHasSingleIndex:i1$fHasSingleIndex:i2$fHasSingleIndex:i3$fHasSingleIndex:i4$fApplicativeIndexing$fFunctorIndexing RightmostRPureRLeafRStepLeftmostLPureLLeafLStepfoldVL__folded__ foldring__ getLeftmost getRightmost$fMonoidLeftmost$fSemigroupLeftmost$fMonoidRightmost$fSemigroupRightmost ifoldVL__ ifolded__ ifoldring__viewscoerceScoerceTcoerceAcoerceBAffineTraversalVL'AffineTraversalVLAffineTraversal' atraversalwithAffineTraversal atraversalVLmatching_cast_gcast AffineFoldafoldVLpreviews atraverseOf_afoldingafailingisn'tmapped__ itraversed__ traversed__OrT Traversed Identity' wrapIdentity'unwrapIdentity' runTraversedwrapOrTuncurry'$fMappingIxStar $fMappingStar$fApplicativeIdentity'$fMonoidTraversed$fSemigroupTraversed$fApplicativeOrT $fFunctorOrT$fFunctorIdentity'foldOf foldMapOffoldrOffoldlOf'toListOfforOf_ sequenceOf_foldingunfoldedpre backwards_summinghashasn'tandOforOfanyOfallOfnoneOf productOfsumOfasumOfmsumOfelemOf notElemOflengthOf maximumOf minimumOf maximumByOf minimumByOffindOffindMOflookupOfiafoldVLipreview ipreviews iatraverseOf_ iafolding filteredBy iafailingIxAffineTraversalVL'IxAffineTraversalVLIxAffineTraversal'IxAffineTraversal iatraversal iatraversalVLunsafeFilteredByignored ifoldMapOfifoldrOf ifoldlOf' itoListOf itraverseOf_iforOf_ifoldingipre ifiltered ibackwards_isummingifailingianyOfiallOfinoneOfifindOfifindMOfIxGetterito selfIndexiviewiviews IxLensVL'IxLensVLIxLens'IxLensilensilensVL toIxLensVL withIxLensVLdevoidifstisnd IxSetter'IxSetterioveriover'isetiset'isetsLensVL'LensVLLens'lenswithLenslensVLtoLensVL withLensVL equality'unitedrootbranchestoMapOfltgtlegePrism'prismprism' withPrismasidewithoutbelowonlynearly_Nothing_Justprefixedsuffixed_Left_RightReversibleOptic ReversedOptic$fReversibleOpticA_Review$fReversibleOpticA_Getter$fReversibleOpticA_ReversedLens$fReversibleOpticA_Lens $fReversibleOpticA_ReversedPrism$fReversibleOpticA_Prism$fReversibleOpticAn_Iso $fChoiceRe $fCochoiceRe $fStrongRe $fCostrongRe$fBicontravariantRe $fBifunctorRe$fProfunctorRe ToReadOnly ReadOnlyOptic$fToReadOnlyA_Foldstab$fToReadOnlyAn_AffineFoldstab$fToReadOnlyA_Getterstab$fToReadOnlyA_ReversedPrismstab$fToReadOnlyA_Traversalstab"$fToReadOnlyAn_AffineTraversalstab$fToReadOnlyA_Prismstab$fToReadOnlyA_Lensstab$fToReadOnlyAn_Isostab ReversedLens'ReversedPrism'reviewuntoSwappedswappedIso'isowithIsoauundersimplecoerced coercedTocoerced1nonnon'anoncurried uncurriedflipped involuted$fSwappedEither $fSwapped(,) MappingOptic MappedOpticmapping"$fMappingOpticA_ReversedLensfgstab$fMappingOpticA_Prismfgstab$fMappingOpticA_Reviewfgstab$fMappingOpticA_Lensfgstab#$fMappingOpticA_ReversedPrismfgstab$fMappingOpticA_Getterfgstab$fMappingOpticAn_IsofgstabEmpty $fAsEmptySeq$fAsEmptyIntSet $fAsEmptySet$fAsEmptyIntMap $fAsEmptyMap$fAsEmptyZipList $fAsEmpty[] $fAsEmpty(,,) $fAsEmpty(,) $fAsEmptyDual$fAsEmptyFirst $fAsEmptyLast$fAsEmptyMaybe $fAsEmptySum$fAsEmptyProduct$fAsEmptyEvent $fAsEmptyAll $fAsEmptyAny $fAsEmpty()$fAsEmptyOrderingSetter'over'setset'sets^?^..#%~%!~!~?~?!~^?!AtatIxedIxKindixIxValueContainscontainsIndexixAtat'sans $fContainsSet$fContainsIntSet$fAtSet $fAtIntSet$fAtMap $fAtIntMap $fAtMaybe$fIxed(,,,,,,,,)$fIxed(,,,,,,,)$fIxed(,,,,,,) $fIxed(,,,,,) $fIxed(,,,,) $fIxed(,,,) $fIxed(,,) $fIxed(,) $fIxedUArray $fIxedArray $fIxedIntSet $fIxedSet $fIxedMap $fIxedIntMap $fIxedSeq $fIxedTree$fIxedIdentity$fIxedNonEmpty$fIxed[] $fIxedMaybe$fIxed-> ArrowOpticoverAassignA$fVisitingWrappedArrow$fChoiceWrappedArrow$fStrongWrappedArrow$fProfunctorWrappedArrow$fArrowWrappedArrow$fCategoryTYPEWrappedArrow!$fArrowOpticAn_AffineTraversalarr$fArrowOpticA_Prismarr$fArrowOpticA_Lensarr$fArrowOpticAn_Isoarr setmappedsetOfmembers TraversalVL' Traversal' traversalVLforOf sequenceOf transposeOf mapAccumLOf mapAccumROfscanl1Ofscanr1Offailover failover'both backwardspartsOfIxTraversalVL' IxTraversalVL IxTraversal' itraversalVLiforOf imapAccumLOf imapAccumROf iscanl1Of iscanr1Of ifailover ifailover' ibackwards elementsOfelements elementOfelementipartsOfEach$fEachiArrayArrayab$fEach[]TreeTreeab$fEachIntSeqSeqab$fEach()MaybeMaybeab$fEach()IdentityIdentityab$fEachIntNonEmptyNonEmptyab$fEachInt[][]ab$fEachIntIntMapIntMapab$fEachkMapMapab$fEachEitherComplexComplexab$fEachEitherEitherEitherab!$fEachInt(,,,,,,,,,)(,,,,,,,,,)ab$fEachInt(,,,,,,,,)(,,,,,,,,)ab$fEachInt(,,,,,,,)(,,,,,,,)ab$fEachInt(,,,,,,)(,,,,,,)ab$fEachInt(,,,,,)(,,,,,)ab$fEachInt(,,,,)(,,,,)ab$fEachInt(,,,)(,,,)ab$fEachInt(,,)(,,)ab$fEachInt(,)(,)ab GPlateInner gplateInner GPlateImpl gplateImplGConstructorTuplegconstructorTupleGConstructorSumgconstructorSumGConstructorImplgconstructorImpl GPositionSum gpositionSum GPositionImpl gpositionImpl GFieldProd gfieldProdGAffineFieldSum gafieldSumGAffineFieldImpl gafieldImpl GSetFieldProd gsetFieldProd GSetFieldSum gsetFieldSum GFieldImpl gfieldImplgenericgeneric1_V1_U1_Par1_Rec1_K1_M1_L1_R1$fGSetFieldSumPathTree:+::+:b$fGSetFieldSumpathM1M1b$fGFieldImplnamestab$fGSetFieldProd[]M1M1r$fGSetFieldProd::*::*:b$fGSetFieldProd::*::*:b0$fGSetFieldProd::*::*:b1$fGSetFieldProd::*::*:b2$fGSetFieldSumPathLeafM1M1b!$fGAffineFieldSumPathTree:+::+:ab$fGAffineFieldSumpathM1M1ab$fGAffineFieldImplTruenamestab$fGAffineFieldMaybeLeftghab$fGAffineFieldSumPathLeafM1M1ab$fGFieldProd[]M1M1rs$fGFieldProd::*::*:ab$fGFieldProd::*::*:ab0$fGFieldProd::*::*:ab1$fGFieldProd::*::*:ab2$fGAffineFieldMaybeRightghab$fGPositionSumPathTree:+::+:ab$fGPositionSumpathM1M1ab$fGPositionImplTruenstab$fGPositionSumPathLeafM1M1ab$fGConstructorSum::+::+:ab$fGConstructorSum::+::+:ab0$fGConstructorSum::+::+:ab1$fGConstructorSum::+::+:ab2$fGConstructorSumpathM1M1ab$fGConstructorImplTruenamestab$fGConstructorTupleU1U1ab$fGConstructorTupleghab$fGConstructorSum[]M1M1ab$fGConstructorTuple:*::*:rs$fGConstructorTuple:*::*:rs0$fGConstructorTuple:*::*:rs1$fGConstructorTuple:*::*:rs2$fGConstructorTupleM1M1rs$fGPlateImplUReca$fGPlateImplV1a$fGPlateImplU1a$fGPlateImplK1a$fGPlateImpl:*:a$fGPlateImpl:+:a$fGPlateImplM1a$fGPlateInnerrepNotDefinedsa$fGPlateInnerTruesa$fGPlateImplK1a0GenericLabelOpticsHasGenericLabelOptics LabelOptic' LabelOptic$fIsLabelnameOptic$fLabelOpticnamekVoid0Void0ab.$fGenericOpticSymbolrepDefined_nameA_Prismstab,$fGenericOpticSymbolrepDefinednameA_Lensstab$fLabelOpticnamekstabIxOptic<%>%><% reindexedicompose icompose3 icompose4 icompose5 icomposeN$fIxOpticA_Setterstab$fIxOpticA_Foldstab$fIxOpticA_Traversalstab$fIxOpticAn_AffineFoldstab$fIxOpticAn_AffineTraversalstab$fIxOpticA_Lensstab$fIxOpticA_GetterstabGPlategplate GConstructor GPosition gposition GAffineFieldgafieldGField$fGFieldnameVoid0Void0ab$fGFieldnamestab$fGAffineFieldnameVoid0Void0ab$fGAffineFieldnamestab$fGPositionnameVoid0Void0ab$fGPositionnstab$fGConstructornameVoid0Void0ab$fGConstructornamestab$fGPlateVoid0a$fGPlateaVoid0 $fGPlateasField9_9Field8_8Field7_7Field6_6Field5_5Field4_4Field3_3Field2_2Field1_2'_3'_4'_5'_6'_7'_8'_9'$fField1(,,,,,,,,)(,,,,,,,,)aa'$fField1(,,,,,,,)(,,,,,,,)aa'$fField1(,,,,,,)(,,,,,,)aa'$fField1(,,,,,)(,,,,,)aa'$fField1(,,,,)(,,,,)aa'$fField1(,,,)(,,,)aa'$fField1(,,)(,,)aa'$fField1(,)(,)aa'$fField1:*::*:ff'$fField1ProductProductff'$fField1IdentityIdentityab$fField2(,,,,,,,,)(,,,,,,,,)bb'$fField2(,,,,,,,)(,,,,,,,)bb'$fField2(,,,,,,)(,,,,,,)bb'$fField2(,,,,,)(,,,,,)bb'$fField2(,,,,)(,,,,)bb'$fField2(,,,)(,,,)bb'$fField2(,,)(,,)bb'$fField2(,)(,)bb'$fField2:*::*:gg'$fField2ProductProductgg'$fField3(,,,,,,,,)(,,,,,,,,)cc'$fField3(,,,,,,,)(,,,,,,,)cc'$fField3(,,,,,,)(,,,,,,)cc'$fField3(,,,,,)(,,,,,)cc'$fField3(,,,,)(,,,,)cc'$fField3(,,,)(,,,)cc'$fField3(,,)(,,)cc'$fField4(,,,,,,,,)(,,,,,,,,)dd'$fField4(,,,,,,,)(,,,,,,,)dd'$fField4(,,,,,,)(,,,,,,)dd'$fField4(,,,,,)(,,,,,)dd'$fField4(,,,,)(,,,,)dd'$fField4(,,,)(,,,)dd'$fField5(,,,,,,,,)(,,,,,,,,)ee'$fField5(,,,,,,,)(,,,,,,,)ee'$fField5(,,,,,,)(,,,,,,)ee'$fField5(,,,,,)(,,,,,)ee'$fField5(,,,,)(,,,,)ee'$fField6(,,,,,,,,)(,,,,,,,,)ff'$fField6(,,,,,,,)(,,,,,,,)ff'$fField6(,,,,,,)(,,,,,,)ff'$fField6(,,,,,)(,,,,,)ff'$fField7(,,,,,,,,)(,,,,,,,,)gg'$fField7(,,,,,,,)(,,,,,,,)gg'$fField7(,,,,,,)(,,,,,,)gg'$fField8(,,,,,,,,)(,,,,,,,,)hh'$fField8(,,,,,,,)(,,,,,,,)hh'$fField9(,,,,,,,,)(,,,,,,,,)ii'Snoc_SnocCons_Cons:>:<<|consuncons_head_tail_init_last|>snocunsnoc$fConsSeqSeqab$fConsZipListZipListab $fCons[][]ab$fSnocSeqSeqab$fSnocZipListZipListab $fSnoc[][]abIntegralintegralbinaryoctaldecimalhexadding subtracting multiplyingdividingexponentiatingnegatedviewLviewRslicedTo slicedFromslicedseqOf ProfunctorifoldlMifoldrMifind iconcatMapiforM_imapM_noneinoneialliany imapAccumL imapAccumRiforMimapMifoldMapDefault imapDefault Data.EitherRightGHC.Base.fmap Data.Foldablefoldr GHC.MaybeJustghc-primGHC.Primcoerce Applicativepure<*>FunctoreitherconstNothingidGHC.RealevenGHC.Enumsucc GHC.Classes/=Data.Typeable.InternalTypeablegcast Data.Tupleuncurry traverse_ sequenceA_Foldable GHC.TypesTrueandorallData.Semigroup.InternalProductproduct getProductSumsumgetSumasummsumelemnotElemlengthmaximumGHC.ErrerrorminimumOrdering maximumBy minimumByfindGHC.ListlookupEither Data.VoidVoidcontainers-0.6.2.1 Data.TreeTree subForestData.Map.InternalunionData.IntMap.InternalMaybe TraversablenullLeftData.Bifunctornotcurrymap$$!headData.Set.InternalSetData.Sequence.InternalSeqD:R:IxValue(,,,,,,,,)IntD:R:IxValue(,,,,,,,)D:R:IxValue(,,,,,,)D:R:IxValue(,,,,,)D:R:IxValue(,,,,)D:R:IxValue(,,,)D:R:IxValue(,,)D:R:IxValue(,) array-0.5.4.0Data.Array.Base!StringBoolCharData.IntSet.InternalIntSetsequencetraversetransformers-0.5.6.2Control.Monad.Trans.State.LazyStatescanl1scanr1Data.Bitraversable BitraversableGHC.IxIxGHC.ArrArrayData.Functor.IdentityIdentityIntMap GHC.Float RealFloat Data.ComplexComplex GHC.GenericsGenerictailinteger-wired-inGHC.Integer.TypeIntegerGHC.NumnegateViewLViewR