!a'      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~           !"#$%&'()*+,-./0 1 2 3 4 5 6 789:;<=>?@ABCDEFGHIJ K L M NOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~!"""#                                         $$$$$%%%%%%%     &&&&& !"#$%&'''(')'*'+','-'.'/'0'1'2'3(4(5)6)7)8)9):*;*<*=*>*?@ABCDEFGHI+J+K+L+M+N+O+P+Q+R+S,T,U,V,W,X,Y,Z,[,\,],^,_,`,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o,p,q,r,s,t,u,v,w,x,y,z,{,|,},~,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--..//0000000000000000011111111111     222222222222222222222223333333333333333333333444444445555555 5 5 5 6 6666666666666666666 6!6"6#6$6%6&6'6(6)6*6+6,6-6.6/606162637475767778797:7;7<7=7>7?7@8A8B8C8D8E8F8G8H8I8J8K8L8M9N9O:P:Q:RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz;{;|;};~;;;;;;;;;;;;;;;;;;                  <<<<<<=Safe&'./48=>?@ACHPSUVX_k84 optics-core0Class that is inhabited by all type-level lists xs5, providing the ability to compose a function under  xs. optics-coreCompose a function under  xs. This generalises () (aka  for (->)M) to work for curried functions with one argument for each type in the list. optics-core%Append two type-level lists together. optics-coreCurry a type-level list.In pseudo (dependent-)Haskell:  xs y =  (->) y xs  optics-core&Show a type surrounded by quote marks.None&'/48=>?@ACHPSUVX_kD]  optics-core Helper for  =* family to visit the first fold only once.  optics-core Helper for  >B and the like for better efficiency than the foldr-based version.Note that the argument a" of the result should not be used. optics-coreComposition operator where the first argument must be an identity function up to representational equivalence (e.g. a newtype wrapper or unwrapper), and will be ignored at runtime. optics-coreComposition operator where the second argument must be an identity function up to representational equivalence (e.g. a newtype wrapper or unwrapper), and will be ignored at runtime. optics-coreWrap the applicative action in  - so that we know later that it was executed.    9 8None&'/48=>?@ACHPSUVX_kW7 optics-coreQNeeded for conversion of indexed affine traversal back to its VL representation.9 optics-coreHNeeded for conversion of affine traversal back to its VL representation.= optics-coreNeeded for indexed setters.@ optics-core Needed for indexed affine folds.C optics-coreNeeded for indexed folds.F optics-coreNeeded for indexed traversals.I optics-coreNeeded for setters.L optics-coreNeeded for affine folds.O optics-coreNeeded for getters and folds.R optics-coreNeeded for traversals.U 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.W optics-coreUnwrap 9.X optics-coreUnwrap 9.Y optics-coreRepack R to change its index type.Z optics-coreRepack O to change its index type.[ optics-coreRepack I to change its index type.\ optics-core45 with type arguments rearranged for TypeApplications.] optics-core35 with type arguments rearranged for TypeApplications.F !#"$&%')(*.-,+/6543210789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]FRSTOPQLMNIJKFGHCDE@AB=>?;<UV9:W78XYZ[/6543210\]*.-,+')($&%!#" None&'/48=>?@ACHPSUVX_k^ optics-core8Type to represent the components of an affine traversal. optics-core,Type to represent the components of a prism. optics-core+Type to represent the components of a lens. optics-core3Type to represent the components of an isomorphism.None&'/48=>?@ACHPSUVX_kc 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. None&'/48=>?@ACHPSUVX_kf optics-coreBTag a value with not one but two phantom type parameters (so that ( can be used as an indexed profunctor).None&'/48=>?@ACHPSUVX_kp|  optics-coreMapping tag types k to constraints on p.fUsing this type family we define the constraints that the various flavours of optics have to fulfill. optics-coreTag for a review. optics-coreTag for a reversed lens. optics-coreTag for a fold. optics-coreTag for an affine fold. 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. optics-coreTag for an iso. None&'./48=>?@ACHPSUVX_k| optics-core3Computes the least upper bound of two optics kinds.Join k l( represents the least upper bound of an Optic k and an Optic l2. This means in particular that composition of an Optic k and an Optic k will yield an Optic (Join k l). optics-core/Subtyping relationship between kinds of optics.An instance of  k l means that any ? k can be used as an ? l. For example, we have an    instance, but not   .AThis class needs instances for all possible combinations of tags. 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.None&',./48=>?@ACHPSUVX_k optics-core=Type synonym for a type-preserving optic as overloaded label. optics-core=Support for overloaded labels as optics. An overloaded label #foo5 can be used as an optic if there is an instance of  "foo" k s t a b.See  Optics.Label" for examples and further details. optics-core@Used to interpret overloaded label syntax. An overloaded label #foo corresponds to  @"foo". optics-core0 is a very simple class which provides a witness Ifoldr f (foldr f init xs) ys = foldr f init (ys ++ xs) where f = (->) It shows that usage of  in '(%%)' is, in fact, safe. optics-core%Proxy type for use as an argument to . 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 . 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 isC is a list of types available as indices. This will typically be  for unindexed optics, or i 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-coreSingleton index list optics-core An alias for an empty index-list optics-core0Explicit cast from one optic flavour to another.uThe 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 '@.EThis 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-coreHFlipped function application, specialised to optics and binding tightly.1Useful for post-composing optics transformations:GtoListOf (ifolded %& ifiltered (\i s -> length s <= i)) ["", "a","abc"]["","a"] optics-core/If no instance matches, GHC tends to bury error messages "No instance for LabelOptic..." within a ton of other error messages about ambiguous type variables and overlapping instances which are irrelevant and confusing. Use overlappable instance providing a custom type error to cut its efforts short.&9 9 9 None&'/48=>?@ACHPSUVX_k  optics-coreInternal implementation of 4A.  None&'/48=>?@ACHPSUVX_k  optics-core Used for  B and C. optics-core Used for  D and E. optics-coreInternal implementation of  F. optics-coreInternal implementation of  G. optics-coreInternal implementation of  H. optics-core Extract the A element. This will fairly eagerly determine that it can return ' the moment it sees any element at all. optics-core Extract the  A element. This will fairly eagerly determine that it can return ' the moment it sees any element at all.          None&'/48=>?@ACHPSUVX_k optics-coreInternal implementation of I. A function considered as an .None&'/48=>?@ACHPSUVX_k optics-coreType synonym for a getter. optics-core&View the value pointed to by a getter. optics-core6View the function of the value pointed to by a getter. optics-coreBuild a getter from a function. Operators to  the type parameters of .None&'/48=>?@ACHPSUVX_k  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 J% that applies to at most one element.None&'/48=>?@ACHPSUVX_k $ optics-coreBType synonym for a type-preserving van Laarhoven affine traversal.% optics-coreAType synonym for a type-modifying van Laarhoven affine traversal.FNote: 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 K has T 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-core@Build 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-core@Convert an affine traversal to its van Laarhoven representation., optics-core"Retrieve the value targeted by an 'V or return the original value while allowing the type to change if it does not match.  L o "a  ( )  . , o - optics-core?Filter result(s) of a traversal that don't satisfy a predicate.Note: This is not a legal JM, unless you are very careful not to invalidate the predicate on the target.*As a counter example, consider that given evens = -  the second J law is violated: 4M evens   NM evens   4M evens (  ) ,So, in order for this to qualify as a legal JL you can only use it for actions that preserve the result of the predicate!For a safe variant see O (or  P for read-only optics). $%&'()*+,- '&(,-)%$*+Optics for working with .None&'/48=>?@ACHPSUVX_k*. optics-coreAn & for working with a  of a  value./ optics-coreAn & for working with a  of a  value.././ A  Q# that contains at most one element.None&'/48=>?@ACHPSUVX_k0 optics-core Type synonym for an affine fold.1 optics-core"Retrieve the value targeted by an 0.5let _Right = prism Right $ either (Left . Left) Rightpreview _Right (Right 'x')Just 'x'preview _Right (Left 'y')Nothing2 optics-core0Retrieve a function of the value targeted by an 0.3 optics-core Create an 0 from a partial function.$preview (afolding listToMaybe) "foo"Just 'f'4 optics-core:Filter result(s) of a fold that don't satisfy a predicate.5 optics-coreTry the first 0-. 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)Note: There is no  R equivalent, because asumming = afailing.6 optics-coreCheck to see if this 0 doesn't match.isn't _Just NothingTrue0123456031246553None&'./48=>?@ACHPSUVX_k 7 optics-core Class for 4s that have an additional read-only index available.9 optics-core Class for 4s that have an additional read-only index available.= optics-core Class for 4s that have an additional read-only index available.E 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.F optics-core^Check whether a list of indices is not empty and generate sensible error message if it's not.G optics-coreIShow useful error message when a function expects optics without indices.I optics-core2Index a traversal by position of visited elements.J 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: J f g is well-defined if and only if f "a  S g.K optics-core Traverse 9 ignoring the results.L optics-coreFlipped K.M optics-coreFlipped 8 optics-coreThe position in the  is available as the index.789<;:=>?@ABCDEFGHIJKLMGFEDBCH?@AIJ=>9<;:KL78M!None&'/48=>?@ACHPSUVX_k  optics-coreInternal implementation of T."None&'/48=>?@ACHPSUVX_k2 optics-coreInternal implementation of U. optics-coreInternal implementation of V. optics-coreInternal implementation of W.#None&'/48=>?@ACHPSUVX_k optics-coreInternal implementation of X. #Extracts elements from a container.None&'/48=>?@ACHPSUVX_k6) optics-coreType synonym for a fold. optics-core Obtain a  by lifting  like function.    "a     "a   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. optics-core&Traverse over all of the targets of a , computing an -based answer, but unlike Y$ do not construct a new structure.  generalizes  to work over any .+traverseOf_ each putStrLn ("hello","world")helloworld  "a    optics-core A version of  with the arguments flipped. optics-core&Evaluate each action in observed by a : on a structure from left to right, ignoring the results.  "a   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. Z[ "a    JtoListOf (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 05 that visits the first element of the original fold. 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] optics-coreTry the first /. If it returns no entries, try the second one. 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 '@ or  \.has _1 ("hello","world")True optics-coreCheck to see if this  or J 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  "a    optics-coreReturns  if any target of a  is .orOf each (True, False)TrueorOf each (False, False)False  "a    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  "a    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  "a   [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  "a   [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"  "a    optics-core#The sum of a collection of actions.msumOf each ("hello","world") "helloworld",msumOf each (Nothing, Just "hello", Nothing) Just "hello"  "a    optics-core/Does the element occur anywhere within a given  of the structure?%elemOf each "hello" ("hello","world")True  "a    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  "a    optics-core0Calculate the number of targets there are for a  in a given container.Note:D This can be rather inefficient for large containers and just like -, this will not terminate for infinite folds.  "a   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 ], '@ or  \ 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  "a ^_ ( "empty")    cIn the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> `a .  o `b- has lazier semantics but could leak memory. optics-core2Obtain the minimum element (if any) targeted by a  safely.Note:  on a valid ], '@ or  \ 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  "a ^_ ( "empty")    cIn the interest of efficiency, This operation has semantics more strict than strictly necessary. \o -> `c .  o `d- has lazier semantics but could leak memory. optics-core2Obtain the maximum element (if any) targeted by a  according to a user supplied .CmaximumByOf folded (compare `on` length) ["mustard","relish","ham"]Just "mustard"aIn the interest of efficiency, This operation has semantics more strict than strictly necessary.  cmp "a ^_ ( "empty")    cmp  optics-core2Obtain the minimum element (if any) targeted by a  according to a user supplied .aIn the interest of efficiency, This operation has semantics more strict than strictly necessary.CminimumByOf folded (compare `on` length) ["mustard","relish","ham"] Just "ham"  cmp "a ^_ ( "empty")    cmp  optics-coreThe  function takes a m, 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  "a    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.OfindMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,4,6) "Checking 1" "Checking 3" "Checking 4"Just 4OfindMOf each (\x -> print ("Checking " ++ show x) >> return (even x)) (1,3,5,7) "Checking 1" "Checking 3" "Checking 5" "Checking 7"Nothing  A :: (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'**631Translates between types with the same structure.None&'/48=>?@ACHPSUVX_k optics-core-This class provides for symmetric bifunctors. optics-core    "a   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]10PYou 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 4M a 4e is working  an isomorphism.  "a 4M  0f  optics-coreThis can be used to lift any  into an arbitrary . 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<Data types that are representationally equal are isomorphic.!view coerced 'x' :: Identity Char Identity 'x' optics-coreType-preserving version of 7 with type parameters rearranged for TypeApplications.'newtype MkInt = MkInt Int deriving Show$over (coercedTo @Int) (*3) (MkInt 2)MkInt 6 optics-coreSpecial case of  for trivial newtype wrappers.5over (coerced1 @Identity) (++ "bar") (Identity "foo")Identity "foobar" optics-coreAThe canonical isomorphism for currying and uncurrying a function.  =    view curried fst 3 43 optics-coreAThe canonical isomorphism for uncurrying and currying a function.  =      = 0f  (view uncurried (+)) (1,2)3 optics-core(The isomorphism for flipping a function.(view flipped (,)) 1 2(2,1) optics-core<Given a function that is its own inverse, this gives you an  using it in both directions.  "a gh  "live" ^. involuted reverse"evil"$"live" & involuted reverse %~ ('d':)"lived"$An indexed version of an 0.None&'/48=>?@ACHPSUVX_k optics-core(Type synonym for an indexed affine fold. 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-core Create an  from a partial function. optics-coreTry the first -. If it returns no entry, try the second one.Note: There is no i equivalent, because iasumming = iafailing.3%An indexed version of an j.None&'/48=>?@ACHPSUVX_k optics-coreJType synonym for a type-preserving van Laarhoven indexed affine traversal. optics-coreIType synonym for a type-modifying van Laarhoven indexed affine traversal.FNote: 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<Type synonym for a type-preserving indexed affine traversal. optics-core;Type synonym for a type-modifying indexed affine traversal. optics-core@Build an indexed affine traversal from a matcher and an updater.If you want to build an - from the van Laarhoven representation, use . optics-coreHBuild an indexed affine traversal from the van Laarhoven representation. optics-coreHConvert an indexed affine traversal to its van Laarhoven representation.An indexed version of an .None&'./48=>?@ACHPSUVX_k optics-core!Type synonym for an indexed fold. optics-core"Obtain an indexed fold by lifting K like function.    "a     "a   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 k# 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 9 class. optics-core Obtain an ) by lifting an operation that returns a 9 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. 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-coreTry the first /. If it returns no entries, try the second one.  optics-coreRetrieve the first entry of an  along with its index.iheadOf ifolded [1..10] Just (0,1)  optics-coreRetrieve the last entry of an  along with its index.ilastOf ifolded [1..10] Just (9,10)  optics-core4Return whether or not any element viewed through an , satisfies a predicate, with access to the i.-When you don't need access to the index then & is more flexible in what it accepts.  o "a   o     optics-core5Return whether or not all elements viewed through an * satisfy a predicate, with access to the i.-When you don't need access to the index then & is more flexible in what it accepts.  o "a   o     optics-core=Return whether or not none of the elements viewed through an * satisfy a predicate, with access to the i.-When you don't need access to the index then & is more flexible in what it accepts.  o "a   o    optics-coreThe  function takes an , a predicate that is also supplied the index, a structure and returns the left-most element of the structure along with its index matching the predicate, or  if there is no such element.-When you don't need access to the index then & is more flexible in what it accepts. optics-coreThe  function takes an , a monadic predicate that is also supplied the index, a structure and returns in the monad the left-most element of the structure matching the predicate, or  if there is no such element.-When you don't need access to the index then & is more flexible in what it accepts.9:;<          9:;<63&An indexed version of an  \.None&'/48=>?@ACHPSUVX_k 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-corePUse a value itself as its own index. This is essentially an indexed version of l. 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.An indexed version of an '@.None&'/48=>?@ACHPSUVX_kb  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-core<Build an indexed lens from the van Laarhoven representation. optics-core<Convert an indexed lens to its van Laarhoven representation. optics-core>Work with an indexed lens in the van Laarhoven representation. optics-core0There is an indexed field for every type in the .set (mapped % devoid) 1 [][]!over (_Just % devoid) abs NothingNothing  An indexed version of an 4e.None&'./48=>?@ACHPSUVX_k 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 "a   o (i _ -> f i) # optics-core"Apply an indexed setter, strictly.$ optics-coreABuild an indexed setter from a function to modify the element(s).% optics-coreIndexed setter via the = class.   % "a > => !"#$% $ %"#!=>Overloaded labels as opticsNone&'/48=>?@ACHPSUVX_kt'#A generalised or first-class field.None&'/48=>?@ACHPSUVX_k(P & 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-coreVBuild 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 "a 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 l.`Useful for strictifying optics with lazy (irrefutable) pattern matching by precomposition, e.g. ,m = / % ,n 0 optics-coreFocus on both sides of an .1 optics-coreMake a )R 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')2 optics-coreWe can always retrieve a () from any type.view united "hello"()set united () "hello""hello"&'()*+,-./012)(*/012+'&,-.(Optics for working with s.None&'/48=>?@ACHPSUVX_k,3 optics-coreA ) that focuses on the root of a .view root $ Node 42 []424 optics-coreA )3 returning the direct descendants of the root of a   o 4 "a 3434+Common abstraction for all kinds of optics.None&'/48=>?@ACHPSUVX_k.REFGFEG)Optics for working with pqs.None&'/48=>?@ACHPSUVX_kJP5 optics-coreConstruct a map from an .%The construction is left-biased (see S), i.e. the first occurences 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"]RfromList [((0,0),'f'),((0,1),'o'),((0,2),'o'),((1,0),'b'),((1,1),'a'),((1,2),'r')]KtoMapOf (folded % ifolded) [('a', "hello"), ('b', "world"), ('a', "dummy")]&fromList [('a',"hello"),('b',"world")]6 optics-coreQFocus on the largest key smaller than the given one and its corresponding value.CMap.fromList [('a', "hi"), ('b', "there")] & over (lt 'b') (++ "!")$fromList [('a',"hi!"),('b',"there")]9ipreview (lt 'a') $ Map.fromList [('a', 'x'), ('b', 'y')]Nothing7 optics-coreRFocus on the smallest key greater than the given one and its corresponding value.CMap.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')8 optics-coreZFocus on the largest key smaller or equal than the given one and its corresponding value.CMap.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')9 optics-core[Focus on the smallest key greater or equal than the given one and its corresponding value.CMap.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')5678956789*None&'/48=>?@ACHPSUVX_kd: optics-coreConstruct a map from an .%The construction is left-biased (see S), i.e. the first occurences 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")]FtoMapOf (icompose (\a b -> 10*a+b) $ ifolded % ifolded) ["foo", "bar"]=fromList [(0,'f'),(1,'o'),(2,'o'),(10,'b'),(11,'a'),(12,'r')]EtoMapOf (folded % ifolded) [(1, "hello"), (2, "world"), (1, "dummy")]"fromList [(1,"hello"),(2,"world")]; optics-coreQFocus 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-coreRFocus 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-coreZFocus 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-core[Focus 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&'/48=>?@ACHPSUVX_k~ ? optics-core)Type synonym for a type-preserving prism.@ optics-core(Type synonym for a type-modifying prism.A optics-core]Build 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.B optics-core This is usually used to build a ?*, when you have to use an operation like rs which already returns a .C optics-core Work with a @ as a constructor and a matcher.D optics-coreUse a @" to work over part of a structure.E optics-core%Given a pair of prisms, project sums. Viewing a @ as a co-'@-, this combinator can be seen to be dual to 't.F optics-coreLift a @ through a  functor, giving a @C that matches only if all the elements of the container match the @.G optics-coreThis @0 compares for exact equality with a given value. only 4 # ()4 5 ^? only 4NothingH 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 uv with the uw list instance):nearly [] null # ()[][1,2,3,4] ^? nearly [] nullNothing H []  :: ? [a] ()To comply with the @" laws the arguments you supply to  nearly a p are somewhat constrained. We assume p x holds iff x "a 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. ?@ABCDEFGH @?ABGHCDEF+Optics for types defined in  GHC.Generics.None&'-/48=>?@ACHPSUVX_kI optics-core:Convert from the data type to its representation (or back)-view (generic % re generic) "hello" :: String"hello"J optics-core:Convert from the data type to its representation (or back) IJKLMNOPQR IJKLMNOPQR,)es for tuple types.None&'/48=>?@ACHPSUVX_klS optics-core,Provides access to the 9th field of a tuple.T optics-core Access the 9th field of a tuple.U optics-core+Provide access to the 8th field of a tuple.V optics-core Access the 8th field of a tuple.W optics-core+Provide access to the 7th field of a tuple.X optics-core Access the 7th field of a tuple.Y optics-core.Provides access to the 6th element of a tuple.Z 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.a optics-core,Provides access to the 2nd field of a tuple.b 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,())c optics-core(Provides access to 1st field of a tuple.d 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)e optics-coreStrict version of df optics-coreStrict version of bg optics-coreStrict version of `h optics-coreStrict version of ^i optics-coreStrict version of \j optics-coreStrict version of Zk optics-coreStrict version of Xl optics-coreStrict version of Vm optics-coreStrict version of TSTUVWXYZ[\]^_`abcdefghijklmcdab_`]^[\YZWXUVSTefghijklm-@ s for the  datatype.None&'/48=>?@ACHPSUVX_ku optics-coreA @ that matches on the  constructor of . optics-coreA @ that matches on the  constructor of ..,Traversals for manipulating parts of a list.None&'/48=>?@ACHPSUVX_k# optics-coreA @0 stripping a prefix from a list when used as a J/, 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 J., 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&'/48=>?@ACHPSUVX_kd optics-coreA @ that matches on the  constructor of . optics-coreA @ that matches on the  constructor of .0The , operator allows some optics to be reversed.None&'./48=>?@ACHPSUVX_kc optics-coreHelper for reversing optics. optics-coreClass for optics that can be versed. optics-coreMInjective type family that maps an optic kind to the optic kind produced by  versing it.   =    =    =    =    =    =    =   optics-core Reverses optics, turning around ] into ], x into y (and back), '@ into  z (and back) and  \ into  { (and back). optics-coreInternal implementation of re.1?Converting read-write optics into their read-only counterparts.None&'/48=>?@ACHPSUVX_k optics-coreCClass for read-write optics that have their read-only counterparts. optics-coreXTurn 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: V> let fstIntToChar = _1 :: Lens (Int, r) (Char, r) Int Char > :t view fstIntToChar  interactive]:1:6: error: " Couldn't match type Char  with Int  Expected type: Optic' A_Lens NoIx (Int, r) Int Actual type: Lens (Int, r) (Char, r) Int Char " In the first argument of view , namely fstIntToChar  In the expression: view fstIntToChar > :t view (getting fstIntToChar) view (getting fstIntToChar) :: (Int, r) -> Int  optics-coreInternal implementation of .  A backwards '@.None&'/48=>?@ACHPSUVX_kO optics-core1Type synonym for a type-preserving reversed lens. optics-core0Type synonym for a type-modifying reversed lens. A backwards x.None&'/48=>?@ACHPSUVX_kΑ optics-core2Type synonym for a type-preserving reversed prism. optics-core1Type synonym for a type-modifying reversed prism.  A backwards  \, i.e. a function.None&'/48=>?@ACHPSUVX_kҦ 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.2A @ for a type that may be .None%&'/48=>?@ACHPSUVX_gk׌ 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 }True3:Optics to access the left or right element of a container.None%&'/48=>?@ACHPSUVX_gk optics-corenThis class provides a way to attach or detach elements on the right side of a structure in a flexible manner. optics-coremThis 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-coreEPattern synonym for matching on the rightmost element of a structure.#case ['a','b','c'] of (_ :> x) -> x'c' optics-coreDPattern 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-corepAttempt 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-coreqAttempt to extract the right-most element from a container, and a version of the container without that element.unsnoc "hello!"Just ("hello",'!') unsnoc ""Nothing5555554*Applies an update to all contained values.None&'/48=>?@ACHPSUVX_k 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: H f :: Int -> (Int, a) -> (Int, a) f k acc | k > 0 = f (k - 1) $  ,n (+1) acc | otherwise = acc Fruns in constant space, but would result in a space leak if used with .Note that replacing  with  or ,n with ,m5 (which amount to the same thing) doesn't help when A is used, because the first coordinate of a pair is never forced. optics-coreApply a setter.  o v "a  o ( v) set _1 'x' ('y', 'z') ('x','z') optics-coreApply a setter, strictly.2TODO DOC: what exactly is the strictness property? optics-corefBuild a setter from a function to modify the element(s), which must respect the well-formedness laws. optics-core Create a  for a .   "a   5*Definitions of infix operators for optics.None&'/48=>?@ACHPSUVX_k  optics-coreFlipped infix version of . optics-coreFlipped infix version of 1. 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-coreSet the target of a  to  a value. o   b "a  o ( b) Nothing & equality ?~ 'x'Just 'x'Map.empty & at 3 ?~ 'x'fromList [(3,'x')]  optics-coreStrict version of ( ).       8888444 4 4 46 Optics for  and -like containers.None&'/48=>?@ACHPSUVX_kP  optics-core  provides a )Q 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 "a   k     optics-core"Map.fromList [(1,"world")] ^. at 1 Just "world"at 1 ?~ "hello" $ Map.emptyfromList [(1,"hello")]Note:s Usage of this function might introduce space leaks if you're not careful to make sure that values put inside the K constructor are evaluated. To force the values and avoid such leaks, use  instead.Note: 6-like containers form a reasonable instance, but not )-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-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-corewType 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-corezType 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  F 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 5 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 "a arr 5  i arr  [(i,e)] "a  i 5 e  arr ' optics-core arr  i "a arr 5  i arr  [(i,e)] "a  i 5 e  arr      7$Turn optics into arrow transformers.None&'/48=>?@ACHPSUVX_k[4 optics-core(Turn an optic into an arrow transformer.5 optics-coreZRun an arrow command and use the output to set all the targets of an optic to the result. QrunKleisli 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   (, , ) optics-core!Internal implementation of overA.3453458&Optics for working with numeric types.None%&'/48=>?@ACHPSUVX_gkxn@ optics-coreFPattern synonym that can be used to construct or pattern match on an  as if it were of any  type.A 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.B optics-core?A prism that shows and reads integers in base-2 through base-36LNote: This is an improper prism, since leading 0s are stripped when reading."100" ^? base 16Just 256 1767707668033969 ^. re (base 36) "helloworld" optics-coreLike , but handles up to base-36 optics-coreLike , but handles up to base-36 optics-coreA safe variant of  optics-core+Select digits that fall into the given base optics-coreA simpler variant of > that only prepends a dash and doesn't know about parentheses optics-coreA simpler variant of \ that supports any base, only recognizes an initial dash and doesn't know about parenthesesC optics-core C = B 2D optics-core D = B 8E optics-core E = B 10F optics-core F = B 16G optics-core G n =  (+n) (subtract n)"[1..3] ^.. traversed % adding 1000[1001,1002,1003]H optics-core H n =  (subtract n) ((+n) H n = 0f (G n) I optics-core I n = iso (*n) (/n)Note: This errors for n = 05 & multiplying 1000 %~ (+3)5.003Flet fahrenheit = multiplying (9/5) % adding 32 in 230 ^. re fahrenheit110.0J optics-core  J n =  (/n) (*n) J n = 0f (I n)Note: This errors for n = 0K optics-core K n =  (**n) (**recip n)Note: This errors for n = 0Fau (coerced1 @Sum % re (exponentiating 2)) (foldMapOf each) (3,4) == 5TrueL optics-core L =     8au (coerced1 @Sum % negated) (foldMapOf each) (3,4) == 7True;au (coerced1 @Sum) (foldMapOf (each % negated)) (3,4) == -7True @ABCDEFGHIJKL BACDEFGHIJKL@9Optics for working with s.None&'/48=>?@ACHPSUVX_kHM 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 J for a ., but you can manipulate it by reading using  and reindexing it via M.(over setmapped (+1) (fromList [1,2,3,4])fromList [2,3,4,5]N 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]MNMN:Optics for working with  s.None&'/48=>?@ACHPSUVX_kO 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]10P 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 J for an  ., but you can manipulate it by reading using  and reindexing it via P.(over setmapped (+1) (fromList [1,2,3,4])fromList [2,3,4,5]Q 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]OPQOPQ>Lifts an effectful operation on elements to act on structures.None&'/48=>?@ACHPSUVX_kR optics-core;Type synonym for a type-preserving van Laarhoven traversal.S optics-core:Type synonym for a type-modifying van Laarhoven traversal.T optics-core-Type synonym for a type-preserving traversal.U optics-core,Type synonym for a type-modifying traversal.V optics-core8Build a traversal from the van Laarhoven representation. V  W "a  W  V "a  W optics-core.Map each element of a structure targeted by a UF, evaluate these actions from left to right, and collect the results.X optics-core A version of W with the arguments flipped.Y optics-coreSEvaluate 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)]   "a Y a "a    Y o "a W o  Z optics-coreThis generalizes  to an arbitrary U.Note: F handles ragged inputs more intelligently, but for non-ragged inputs:'transposeOf traversed [[1,2,3],[4,5,6]][[1,4],[2,5],[3,6]]  "a Z   [ optics-coreThis generalizes  to an arbitrary U.  "a [   [ accumulates   from left to right.\ optics-coreThis generalizes  to an arbitrary U.  "a \ a \ accumulates   from right to left.] optics-coreThis permits the use of  over an arbitrary U.  "a ] a ^ optics-coreThis permits the use of  over an arbitrary U.  "a ^ a _ optics-core Try to map a function over this U5, 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.a optics-core Construct a U via the  class. W a =   b optics-coreThis allows you to  4 the elements of a traversal in the opposite order.c optics-corec turns a U into a ).Note:X 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')pAny 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.RSTUVWXYZ[\]^_`abcUTVWaXYZ\[^]_`bcSRAn indexed version of an U.None&'./48=>?@ACHPSUVX_kՕd optics-coreCType synonym for a type-preserving van Laarhoven indexed traversal.e optics-coreBType synonym for a type-modifying van Laarhoven indexed traversal.f optics-core5Type synonym for a type-preserving indexed traversal.g optics-core4Type synonym for a type-modifying indexed traversal.h optics-coreABuild an indexed traversal from the van Laarhoven representation. h  i "a  i  h "a  i optics-core.Map each element of a structure targeted by a g\ (supplying the index), evaluate these actions from left to right, and collect the results.EThis yields the van Laarhoven representation of an indexed traversal.j optics-core A version of i with the arguments flipped.k optics-core Generalizes  to an arbitrary g.k& accumulates state from left to right. [ o "a k o   l optics-core Generalizes  to an arbitrary g.l& accumulates state from right to left. \ o "a l o   m optics-coreThis permits the use of  over an arbitrary g.n optics-coreThis permits the use of  over an arbitrary g.o optics-core5Try to map a function which uses the index over this g , returning  if the g has no targets.p optics-core Version of o+ strict in the application of the function.q optics-coreIndexed traversal via the 7 class. i q "a 8 2iover (itraversed <%> itraversed) (,) ["ab", "cd"]5[[((0,0),'a'),((0,1),'b')],[((1,0),'c'),((1,1),'d')]]r optics-coreThis is the trivial empty g.6 & ignored %~ absurd6s optics-coreFilter results of an g0 that don't satisfy a predicate on the indices..toListOf (itraversed %& indices even) "foobar""foa"t optics-coreThis allows you to  = the elements of an indexed traversal in the opposite order.u optics-core Traverse selected elements of a U2 where their ordinal positions match a predicate.v optics-coreTraverse elements of a < container where their ordinal positions match a predicate. v "a u   w optics-core Traverse the nth element of a U if it exists.?TODO: the result ideally should be an indexed affine traversal.x optics-core Traverse the nth element of a  container. x "a w a y optics-coreAn indexed version of c: that receives the entire list of indices as its indices.78defghijklmnopqrstuvwxygfhiqruvwxjklmnopstyed78;An g; for each element of a (potentially monomorphic) container.None&'/48=>?@ACHPSUVX_kz 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 => g i ( i a) ( i b) a b} optics-core { :: g [Int] ( a) ( b) a b~ optics-core { :: g  ( a) ( b) a b optics-core { :: g () ( a) ( b) a b optics-core { :: g () ( a) ( b) a b optics-core { :: g  (NonEmpty a) (NonEmpty b) a b optics-core { :: g  [a] [b] a b optics-core { :: g  ( a) ( b) a b optics-core { :: g k ( k a) ( k b) a b optics-core { :: ( a,  b) => g (Either () ()) ( a) ( b) a b optics-core { :: g ( () ()) ( a a) ( b b) a b optics-core { :: g C (a, a, a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b, b, b) a b optics-core { :: g = (a, a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b, b) a b optics-core { :: g 7 (a, a, a, a, a, a, a, a) (b, b, b, b, b, b, b, b) a b optics-core { :: g 1 (a, a, a, a, a, a, a) (b, b, b, b, b, b, b) a b optics-core { :: g * (a, a, a, a, a, a) (b, b, b, b, b, b) a b optics-core { :: g $ (a, a, a, a, a) (b, b, b, b, b) a b optics-core { :: g  (a, a, a, a) (b, b, b, b) a b optics-core { :: g  (a, a, a) (b, b, b) a b optics-core { :: g  (a, a) (b, b) a bz{z{ $Core definitions for indexed optics.None&'./48=>?@ACHPSUVX_kf  optics-core,Class for optic kinds that can have indices. optics-core5Convert an indexed optic to its unindexed equivalent. optics-coreACompose two indexed optics. Their indices are composed as a pair..itoListOf (ifolded <%> ifolded) ["foo", "bar"]I[((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"]I[((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.QitoListOf (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-coreAFlatten indices obtained from arbitrary number of indexed optics.n789:;<=>JKLM      !"#$%defghijklmnopqrstuvwxyJ=>9:;<KL78M9 9 9 *The core optics functionality re-exported.None&'/48=>?@ACHPSUVX_k Ob !"#$%&'()*+,-0123456789:;<=>EFGJKLM      !"#$%&'()*+,-./012?@ABCDEFGHSTUVWXYZ[\]^_`abcdefghijklm     345RSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{<Optics for working with s.None&'/48=>?@ACHPSUVX_k'w optics-coreA  is isomorphic to a   m "a m 5 Seq.fromList [1,2,3] ^. viewL1 :< fromList [2,3]Seq.empty ^. viewLEmptyLEmptyL ^. re viewL fromList []&review viewL $ 1 Seq.:< fromList [2,3]fromList [1,2,3] optics-coreA  is isomorphic to a   m "a m 5 Seq.fromList [1,2,3] ^. viewRfromList [1,2] :> 3Seq.empty ^. viewREmptyREmptyR ^. re viewR fromList []&review viewR $ fromList [1,2] Seq.:> 3fromList [1,2,3] optics-coreTraverse the first n elements of a #fromList [1,2,3,4,5] ^.. slicedTo 2[1,2]*fromList [1,2,3,4,5] & slicedTo 2 %~ (*10)fromList [10,20,3,4,5]'fromList [1,2,4,5,6] & slicedTo 10 .~ 0fromList [0,0,0,0,0] optics-coreTraverse all but the first n elements of a %fromList [1,2,3,4,5] ^.. slicedFrom 2[3,4,5],fromList [1,2,3,4,5] & slicedFrom 2 %~ (*10)fromList [1,2,30,40,50])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 *fromList [1,2,3,4,5] & sliced 1 3 %~ (*10)fromList [1,20,30,4,5]#fromList [1,2,3,4,5] ^.. sliced 1 3[2,3]&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]      !"#$%&'()*+,-./01234456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrsttuvw??xyz{|}~ \ o  |j  L   P       !""" #! Q F " # $ % & > ' ( G ) H * + , R = - . D B / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ ABCD]EFGHIlJKLMNOPQRS$T$U$V$W$X%Y%Z%[%\%]%^%_`UabcdefVgWhijikEClmnop&q&r&s&t&uvwxyz{|}~T''''@''''''''t'(()))))*****x++++++++++,,,,,,,,,,,,,,,,,,n,m,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,--..//000f00000000 0 0 0 0 0011111111111  zy {  2w2v22 2!2"2#2$2%2&2'2(2)2*2+2,2-2.2/202122233435363738393:3;3<3=3>3?3@3A3B3C3D3E3F3G3H3I4J4e4M4K4L4M4N4A55O5P5Q5R5S55T5U5V6W6X6Y6Z6[6\6]6^6_6`6a6b6c6d6e6f6g6h6i6j6k6l6m6n6o6p6q6r6s6t6u6v6w6x6y6z6{6|6}7~777777777777888888888888899:::KJYIkXO;;;;;;;;;;;;;;;;;;;;;;  S                <<<<<<rsr      !"#$%&'(),)-)+*+*,-./ 01 02 34 5467890:0;1<=>'?'@AB 3q CDEF6GH6I6J6K6L6M6N6OPQRPQST7UVWX8Y8Z8[8\8]8^_` abcdefg'h'iEjkl 5mnopq  r  s  t  uv&optics-core-0.1-KtEG5c7xngP9iYSc6cGk4v Optics.OpticOptics.Internal.Optic.TypeLevelOptics.Internal.UtilsOptics.Internal.ProfunctorOptics.Internal.ConcreteOptics.Internal.BiOptics.Internal.TaggedOptics.Internal.Optic.Types Optics.ReviewOptics.ReversedLens Optics.FoldOptics.AffineFold Optics.GetterOptics.ReversedPrismOptics.IxSetterOptics.TraversalOptics.AffineTraversal Optics.Prism Optics.IxLens Optics.IsoOptics.Internal.Optic.Subtyping Optics.LabelOptics.Internal.OpticOptics.Internal.SetterOptics.Internal.FoldOptics.Internal.Traversal Optics.CoerceData.Typeable.OpticsOptics.IxTraversal Optics.IxFoldOptics.Internal.IndexedOptics.Indexed.CoreOptics.Internal.IxSetterOptics.Internal.IxFoldOptics.Internal.IxTraversalOptics.IxAffineFoldOptics.IxAffineTraversalOptics.IxGetter Optics.LensData.Tree.OpticsData.Map.OpticsData.IntMap.OpticsGHC.Generics.OpticsData.Tuple.OpticsData.Maybe.OpticsData.List.OpticsData.Either.Optics Optics.ReOptics.ReadOnlyOptics.Empty.CoreOptics.Cons.Core Optics.SetterOptics.OperatorsOptics.At.Core Optics.ArrowNumeric.OpticsData.Set.OpticsData.IntSet.OpticsOptics.Each.CoreData.Sequence.Opticsfailing traverseOf_OpticLensmappedlastOfilastOfheadOfiheadOffoldVLfoldedfoldring traversed Traversal TraversalVLpreviewoverOpticsindicesfilteredFoldsummingnoIximappedifoldVLifolded ifoldring itraversed traverseOfPreludeunfoldrGetterIso Data.Maybe fromMaybeData.SemigroupgetMaxMaxgetMinMinSetterre Control.MonadjoinisummingAffineTraversal itraverseOfequality_1'_1viewData.MapMap Data.Typeablecast alongside Optics.Empty_EmptyAsEmptyPrism ReversedPrism ReversedLensReviewto Data.WordWord8.~^. Data.Char intToDigit digitToIntNumeric showSigned readSigned Data.List transposeData.Traversable mapAccumL mapAccumR Optics.Corebase Data.Function& Data.Functor<&> CurryComposecomposeNAppendCurry QuoteType$fCurryCompose:$fCurryCompose[]OrT TraversedContext#..# runTraversedwrapOrT$fMonoidTraversed$fSemigroupTraversed$fApplicativeOrT$fFunctorContext $fFunctorOrTMappingroamiroam TraversingwanderiwanderVisitingvisitivisitCochoiceunleftunrightChoiceleft'right'CostrongunfirstunsecondStrongfirst'second'linearilinear Profunctordimaplmaprmaplcoerce'rcoerce' conjoined__ ixcontramapIxStarAStarA Identity' IxFunArrow runIxFunArrow IxForgetM runIxForgetMIxForget runIxForgetIxStar runIxStarFunArrow runFunArrowForgetM runForgetMForget runForgetStarrunStar wrapIdentity'unwrapIdentity'runStarA runIxStarAreStarreForget reFunArrowrcoercelcoerce$fApplicativeIdentity'$fProfunctorIxFunArrow$fProfunctorIxForgetM$fProfunctorIxForget$fProfunctorIxStar$fProfunctorIxStarA$fProfunctorFunArrow$fProfunctorForgetM$fProfunctorForget$fProfunctorStar$fProfunctorStarA$fStrongIxFunArrow$fStrongIxForgetM$fStrongIxForget$fStrongIxStar$fStrongIxStarA$fStrongFunArrow$fStrongForgetM$fStrongForget $fStrongStar $fStrongStarA$fChoiceIxFunArrow$fChoiceIxForgetM$fChoiceIxForget$fChoiceIxStar$fChoiceIxStarA$fChoiceFunArrow$fChoiceForgetM$fChoiceForget $fChoiceStar $fChoiceStarA$fCochoiceIxForgetM$fCochoiceIxForget$fCochoiceForgetM$fCochoiceForget$fVisitingIxFunArrow$fVisitingIxForgetM$fVisitingIxForget$fVisitingIxStar$fVisitingIxStarA$fVisitingFunArrow$fVisitingForgetM$fVisitingForget$fVisitingStar$fVisitingStarA$fTraversingIxFunArrow$fTraversingIxForget$fTraversingIxStar$fTraversingFunArrow$fTraversingForget$fTraversingStar$fMappingIxFunArrow$fMappingIxStar$fMappingFunArrow $fMappingStar$fFunctorIdentity' AffineMarketMarketStoreExchange$fProfunctorExchange $fStrongStore$fProfunctorStore$fChoiceMarket$fProfunctorMarket$fFunctorMarket$fVisitingAffineMarket$fStrongAffineMarket$fChoiceAffineMarket$fProfunctorAffineMarketBicontravariant contrabimap contrafirst contrasecond Bifunctorbimapfirstsecondlphantomrphantom$fBicontravariantIxForgetM$fBicontravariantIxForget$fBicontravariantForgetM$fBicontravariantForgetTaggedunTagged$fCostrongTagged$fChoiceTagged$fProfunctorTagged$fBifunctorTagged$fFunctorTagged ConstraintsA_ReviewA_ReversedLensA_Fold An_AffineFoldA_GetterA_ReversedPrismA_Setter A_TraversalAn_AffineTraversalA_PrismA_LensAn_IsoJoinIsimplies$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 LabelOptic' LabelOptic labelOpticIsProxyOptic__Optic_Optic'getOpticWithIxNoIx castOptic%%%%&$fAppendProof:ys:$fAppendProof[]yszs$fIsLabelnameOptic$fLabelOpticnamekstabmapped__ RightmostRPureRLeafRStepLeftmostLPureLLeafLStepfoldVL__folded__ foldring__ getLeftmost getRightmost$fMonoidLeftmost$fSemigroupLeftmost$fMonoidRightmost$fSemigroupRightmost traversed__viewscoerceScoerceTcoerceAcoerceBAffineTraversalVL'AffineTraversalVLAffineTraversal' atraversalwithAffineTraversal atraversalVLtoAtraversalVLmatchingunsafeFiltered_cast_gcast AffineFoldpreviewsafoldingafailingisn'tTraversableWithIndex itraverseFoldableWithIndexifoldMapifoldrifoldl'FunctorWithIndeximapIndexing runIndexingIntT ShowTypesHasSingleIndexNonEmptyIndicesAcceptsEmptyIndicesunIntTindexing conjoined itraverse_ifor_ifor$fAcceptsEmptyIndicesf[]$fAcceptsEmptyIndicesf:$fNonEmptyIndices:$fNonEmptyIndices[]$fHasSingleIndex[]i$fHasSingleIndex:i$fHasSingleIndex:i0$fHasSingleIndex:i1$fHasSingleIndex:i2$fHasSingleIndex:i3$fHasSingleIndex:i4$fApplicativeIndexing$fFunctorIndexing$fTraversableWithIndexVoidK1$fFoldableWithIndexVoidK1$fFunctorWithIndexVoidK1$fTraversableWithIndexiRec1$fFoldableWithIndexiRec1$fFunctorWithIndexiRec1$fTraversableWithIndexEither:+:$fFoldableWithIndexEither:+:$fFunctorWithIndexEither:+:$fTraversableWithIndexEither:*:$fFoldableWithIndexEither:*:$fFunctorWithIndexEither:*:$fTraversableWithIndex(,):.:$fFoldableWithIndex(,):.:$fFunctorWithIndex(,):.:$fTraversableWithIndex()Par1$fFoldableWithIndex()Par1$fFunctorWithIndex()Par1$fTraversableWithIndexVoidU1$fFoldableWithIndexVoidU1$fFunctorWithIndexVoidU1$fTraversableWithIndexVoidV1$fFoldableWithIndexVoidV1$fFunctorWithIndexVoidV1$fFunctorWithIndex(,)ReaderT $fTraversableWithIndexiIdentityT$fFoldableWithIndexiIdentityT$fFunctorWithIndexiIdentityT$fTraversableWithIndexiReverse$fFoldableWithIndexiReverse$fFunctorWithIndexiReverse $fTraversableWithIndexiBackwards$fFoldableWithIndexiBackwards$fFunctorWithIndexiBackwards$fTraversableWithIndexVoidProxy$fFoldableWithIndexVoidProxy$fFunctorWithIndexVoidProxy$fTraversableWithIndex[]Tree$fFoldableWithIndex[]Tree$fFunctorWithIndex[]Tree#$fTraversableWithIndexEitherProduct $fFoldableWithIndexEitherProduct$fFunctorWithIndexEitherProduct$fTraversableWithIndexEitherSum$fFoldableWithIndexEitherSum$fFunctorWithIndexEitherSum $fTraversableWithIndex(,)Compose$fFoldableWithIndex(,)Compose$fFunctorWithIndex(,)Compose$fTraversableWithIndexiArray$fFoldableWithIndexiArray$fFunctorWithIndexiArray$fTraversableWithIndexkMap$fFoldableWithIndexkMap$fFunctorWithIndexkMap$fTraversableWithIndexIntIntMap$fFoldableWithIndexIntIntMap$fFunctorWithIndexIntIntMap$fTraversableWithIndexIntSeq$fFoldableWithIndexIntSeq$fFunctorWithIndexIntSeq$fTraversableWithIndex()Maybe$fFoldableWithIndex()Maybe$fFunctorWithIndex()Maybe!$fTraversableWithIndexIntNonEmpty$fFoldableWithIndexIntNonEmpty$fFunctorWithIndexIntNonEmpty $fTraversableWithIndexIntZipList$fFoldableWithIndexIntZipList$fFunctorWithIndexIntZipList$fTraversableWithIndexInt[]$fFoldableWithIndexInt[]$fFunctorWithIndexInt[]$fFunctorWithIndexr->$fTraversableWithIndexk(,)$fFoldableWithIndexk(,)$fFunctorWithIndexk(,) $fTraversableWithIndex()Identity$fFoldableWithIndex()Identity$fFunctorWithIndex()Identity imapped__ ifoldVL__ ifolded__ ifoldring__ itraversed__foldOf foldMapOffoldrOffoldlOf'toListOfforOf_ sequenceOf_foldingunfoldedpre backwards_hashasn'tandOforOfanyOfallOfnoneOf productOfsumOfasumOfmsumOfelemOf notElemOflengthOf maximumOf minimumOf maximumByOf minimumByOffindOffindMOflookupOfSwappedswappedIso'isowithIsoauundermappingsimplecoerced coercedTocoerced1curried uncurriedflipped involuted$fSwappedEither $fSwapped(,) IxAffineFoldipreview ipreviews iafolding iafailingIxAffineTraversalVL'IxAffineTraversalVLIxAffineTraversal'IxAffineTraversal iatraversal iatraversalVLtoIxAtraversalVLIxFold ifoldMapOfifoldrOf ifoldlOf' itoListOf itraverseOf_iforOf_ifoldingipre ifiltered ibackwards_ifailingianyOfiallOfinoneOfifindOfifindMOfIxGetterito selfIndexiviewiviews IxLensVL'IxLensVLIxLens'IxLensilensilensVL toIxLensVL withIxLensVLdevoid IxSetter'IxSetterioveriover'isetiset'isetsLensVL'LensVLLens'lenswithLenslensVLtoLensVL withLensVL equality'chosenunitedrootbranchestoMapOfltgtlegePrism'prismprism' withPrismasidewithoutbelowonlynearlygenericgeneric1_V1_U1_Par1_Rec1_K1_M1_L1_R1Field9_9Field8_8Field7_7Field6_6Field5_5Field4_4Field3_3Field2_2Field1_2'_3'_4'_5'_6'_7'_8'_9'$fGIxednM1M1ab$fGIxedn:*::*:ab$fGIxedZK1K1ab$fGIxed'Tnss'ts'ab$fField1(,,,,,,,,)(,,,,,,,,)aa'$fField1(,,,,,,,)(,,,,,,,)aa'$fField1(,,,,,,)(,,,,,,)aa'$fField1(,,,,,)(,,,,,)aa'$fField1(,,,,)(,,,,)aa'$fField1(,,,)(,,,)aa'$fField1(,,)(,,)aa'$fField1(,)(,)aa'$fField1:*::*:ff'$fField1ProductProductff'$fField1IdentityIdentityab$fGIxed'Fnss'st'ab$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'_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 ToReadOnlygetting$fToReadOnlyA_Foldstab$fToReadOnlyAn_AffineFoldstab$fToReadOnlyA_Getterstab$fToReadOnlyA_ReversedPrismstab$fToReadOnlyA_Traversalstab"$fToReadOnlyAn_AffineTraversalstab$fToReadOnlyA_Prismstab$fToReadOnlyA_Lensstab$fToReadOnlyAn_Isostab ReversedLens'ReversedPrism'reviewuntoEmpty $fAsEmptySeq$fAsEmptyIntSet $fAsEmptySet$fAsEmptyIntMap $fAsEmptyMap$fAsEmptyZipList $fAsEmpty[] $fAsEmpty(,,) $fAsEmpty(,) $fAsEmptyDual$fAsEmptyFirst $fAsEmptyLast$fAsEmptyMaybe $fAsEmptySum$fAsEmptyProduct$fAsEmptyEvent $fAsEmptyAll $fAsEmptyAny $fAsEmpty()$fAsEmptyOrderingSnoc_SnocCons_Cons:>:<<|consuncons_head_tail_init_last|>snocunsnoc$fConsSeqSeqab$fConsZipListZipListab $fCons[][]ab$fSnocSeqSeqab$fSnocZipListZipListab $fSnoc[][]abSetter'over'setset'sets^?^..#%~%!~!~?~?!~AtatIxedixIxValueContainscontainsIndexixAtat'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_IsoarrIntegralintegralbinaryoctaldecimalhexadding subtracting multiplyingdividingexponentiatingnegated setmappedsetOfmembers TraversalVL' Traversal' traversalVLforOf sequenceOf transposeOf mapAccumLOf mapAccumROfscanl1Ofscanr1Offailover failover' backwardspartsOfIxTraversalVL' IxTraversalVL IxTraversal' IxTraversal itraversalVLiforOf imapAccumLOf imapAccumROf iscanl1Of iscanr1Of ifailover ifailover'ignored ibackwards elementsOfelements elementOfelementipartsOfEacheach$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(,)(,)abIxOptic<%>%><% reindexedicompose icompose3 icompose4 icompose5 icomposeN$fIxOpticA_Setterstab$fIxOpticA_Foldstab$fIxOpticA_Traversalstab$fIxOpticAn_AffineFoldstab$fIxOpticAn_AffineTraversalstab$fIxOpticA_Lensstab$fIxOpticA_GetterstabviewLviewRslicedTo slicedFromslicedseqOfGHC.Base.fmap Data.Foldablefoldr AppendProof Unsafe.Coerce unsafeCoerce GHC.MaybeJustghc-primGHC.Primcoerce Applicativepure<*> Data.EithereitherconstNothingidGHC.RealevenGHC.Enumsucc GHC.Classes/=Data.Typeable.InternalTypeablegcast TraversableFoldableFunctorcontainers-0.6.0.1Data.Sequence.InternalSeq traverse_ sequenceA_ GHC.TypesTrueandorallData.Semigroup.InternalProductproduct getProductSumsumgetSumasummsumelemnotElemlengthmaximumGHC.ErrerrorminimumOrdering maximumBy minimumByfindGHC.ListlookupData.Bifunctor Data.Tuplecurryuncurry Data.VoidVoidEither Data.TreeTree subForestData.Map.InternalunionData.IntMap.InternalMaybenullLeftRightRere__ getting__StringCharheadtail$$!Data.Set.InternalSetGHC.ArrArrayD: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.3.0Data.Array.Base!//BooloverA__ integer-gmpGHC.Integer.TypeInteger intToDigit' digitToInt' digitToIntMayisDigit' showSigned' readSigned'GHC.NumnegateData.IntSet.InternalIntSetsequencetraversetransformers-0.5.5.0Control.Monad.Trans.State.LazyStatescanl1scanr1IxData.Functor.IdentityIdentityIntMap GHC.Float RealFloat Data.ComplexComplexViewLviewlViewRviewr