h$q      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF G H I J K L M N O P Q R S T U V WXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~                   Optics for working with s.None'(059>?< optics-extraConstruct a hash 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 (folded % ifolded) [('a', "hello"), ('b', "world"), ('a', "dummy")]&fromList [('a',"hello"),('b',"world")]-<<-Optics for working with s.None'(059>? Z= optics-extraThis % can be used to change the type of a ( by mapping the elements to new values. Sadly, you can't create a valid  for a ., but you can manipulate it by reading using  and reindexing it via =.0over setmapped (+1) (HashSet.fromList [1,2,3,4])fromList [2,3,4,5]> optics-extra Construct a  from a fold.setOf folded ["hello","world"]fromList ["hello","world"]7setOf (folded % _2) [("hello",1),("world",2),("!!!",3)]fromList [1,2,3]=>=>Optics for working with lazy .None&'(059>?@ optics-extra This isomorphism can be used to pack (or unpack) lazy ."hello" ^. packed -- :: Text"hello" pack x D x  @ unpack x D x   @ @ D  A A optics-extra This isomorphism can be used to unpack (or pack) lazy .*Text.pack "hello" ^. unpacked -- :: String"hello" pack x D x   A unpack x D x  @ This  is provided for notational convenience rather than out of great need, since A D  @ B optics-extraThis is an alias for A+ that makes it clearer how to use it with (). B =  @ _Text # "hello" -- :: Text"hello"C optics-extraConvert between lazy  and Builder .  fromLazyText x D x  C  toLazyText x D x   C D optics-extra(Traverse the individual characters in a .'anyOf text (=='c') $ Text.pack "chello"True D = A %  When the type is unambiguous, you can also use the more general *. D D * $Note that when just using this as a ,    can be more efficient.E optics-extraEncode/Decode a lazy  to/from lazy  , via UTF-8.Note: This function does not decode lazily, as it must consume the entire input before deciding whether or not it fails.!LBS.unpack (utf8 # Text.pack "L") [226,152,131]?@ABCDE@ABDCE? Optics for working with strict .None&'(059>?3G optics-extra This isomorphism can be used to pack (or unpack ) strict ."hello" ^. packed -- :: Text"hello" pack x D x  G unpack x D x   G G D  H G D  pack unpack H optics-extra This isomorphism can be used to unpack (or pack ) strict .,Strict.pack "hello" ^. unpacked -- :: String"hello"This  is provided for notational convenience rather than out of great need, since H D  G pack x D x   H unpack x D x  G H D  unpack pack I optics-extraThis is an alias for H0 that makes it more obvious how to use it with  > _Text # "hello" -- :: Text"hello"J optics-extraConvert between strict  and Builder . fromText x D x  J  ( toLazyText x) D x   J K optics-extra-Traverse the individual characters in strict .(anyOf text (=='o') (Strict.pack "hello")TrueWhen the type is unambiguous, you can also use the more general *. K D H %  K D * $Note that when just using this as a ,  !  can be more efficient.L optics-extraEncode/Decode a strict  to/from strict  , via UTF-8.utf8 # Strict.pack "L""\226\152\131"FGHIJKLGHJKLIF 'Optics for working with strict or lazy Q.None&'(059>?M optics-extraTraversals for strict or lazy QN optics-extra This isomorphism can be used to pack (or unpack) strict or lazy Q. pack x D x  N unpack x D x   N N D  R O optics-extraConvert between strict or lazy Q and a Builder. fromText x D x  O P optics-extra5Traverse the individual characters in strict or lazy Q. P = R .  R optics-extra This isomorphism can be used to unpack (or pack) both strict or lazy Q. unpack x D x  R pack x D x   R This  is provided for notational convenience rather than out of great need, since R D  N S optics-extraThis is an alias for R+ that makes it clearer how to use it with (). S =  N _Text # "hello" :: Strict.Text"hello"MPONQRSMPONRSQ Optics for " and #$-like containers.None'(059>?& ,-./10254376 /2543.76-,10:Optics to access the left or right element of a container.None'(059>?A  for a type that may be 9.None'(059>?J8:9:98 None'(059>?} optics-extraTraverse a strict  in a relatively balanced fashion, as a balanced tree with biased runs of elements at the leaves.~ optics-extraTraverse a strict  in a relatively balanced fashion, as a balanced tree with biased runs of elements at the leaves, pretending the bytes are chars. optics-extraAn # of the individual bytes in a lazy . optics-extraAn # of the individual bytes in a lazy ! pretending the bytes are chars.}~}~ None&'(059>?( optics-extra%& (or %') a list of bytes into a   D   %& x D x   %' x D x    $[104,101,108,108,111] ^. packedBytes"hello" optics-extra%' (or %&) a  into a list of bytes.  D   %' x D x   %& x D x    &"hello" ^. packedChars % unpackedBytes[104,101,108,108,111] optics-extraTraverse each  in a .This  walks the  in a tree-like fashion enable zippers to seek to locations in logarithmic time and accelerating many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:  D    *anyOf bytes (== 0x80) (Char8.pack "hello")False$Note that when just using this as a ,  %  can be more efficient. optics-extra(& (or (') a list of characters into a When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.  D   (& x D x   (' x D x    foldOf (packedChars % each % to (\w -> let x = showHex w "" in if Prelude.length x == 1 then '0':x else x)) "hello" "68656c6c6f" optics-extra(' (or (&) a list of characters into a When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.  D   (' x D x   (& x D x    4[104,101,108,108,111] ^. packedBytes % unpackedChars"hello" optics-extra#Traverse the individual bytes in a  as characters.When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.This  walks the  in a tree-like fashion enable zippers to seek to locations in logarithmic time and accelerating many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:  =    )anyOf chars (== 'h') $ Char8.pack "hello"True None&'(059>?2D optics-extra)& (or )') a list of bytes into a .  D   %& x D x   %' x D x    :[104,101,108,108,111] ^. packedBytes == Char8.pack "hello"True optics-extra)' (or )&) a  into a list of bytes.  D   %' x D x   %& x D x    &"hello" ^. packedChars % unpackedBytes[104,101,108,108,111] optics-extra#Traverse the individual bytes in a .This  walks each strict  chunk in a tree-like fashion enable zippers to seek to locations more quickly and accelerate many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:  D    *anyOf bytes (== 0x80) (Char8.pack "hello")False$Note that when just using this as a ,  )  can be more efficient. optics-extra*& (or *') a list of characters into a .When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.  D   (& x D x   (' x D x    foldOf (packedChars % each % to (\w -> let x = showHex w "" in if Prelude.length x == 1 then '0':x else x)) "hello" "68656c6c6f" optics-extra*' (or *&) a list of characters into a When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.  D   (' x D x   (& x D x    4[104,101,108,108,111] ^. packedBytes % unpackedChars"hello" optics-extra#Traverse the individual bytes in a  as characters.When writing back to the  it is assumed that every  lies between 'x00' and 'xff'.This  walks each strict  chunk in a tree-like fashion enable zippers to seek to locations more quickly and accelerate many monoidal queries, but up to associativity (and constant factors) it is equivalent to:  =    )anyOf chars (== 'h') $ Char8.pack "hello"TrueNone&'(059>?; optics-extraTraversals for ByteStrings. optics-extra%& (or %')) a list of bytes into a strict or lazy  ByteString. %& x D x   %' x D x     D    optics-extra(& (or ('.) a list of characters into a strict or lazy  ByteString.When writing back to the  ByteString it is assumed that every  lies between 'x00' and 'xff'. (& x D x   (' x D x     D    optics-extraTraverse each  in a strict or lazy  ByteStringThis  walks each strict  ByteString chunk in a tree-like fashion enable zippers to seek to locations more quickly and accelerate many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:  D      ( 0x80) ::  ByteString ->   optics-extra2Traverse the individual bytes in a strict or lazy  ByteString as characters.When writing back to the  ByteString it is assumed that every  lies between 'x00' and 'xff'.This  walks each strict  ByteString chunk in a tree-like fashion enable zippers to seek to locations more quickly and accelerate many monoidal queries, but up to associativity (and constant factors) it is equivalent to the much slower:  D      ( 'c') ::  ByteString ->   optics-extra%' (or %&) a  ByteString into a list of bytes.  D   %' x D x   %& x D x     ::  %+ []  ::  )+ []  optics-extra(' (or (&0) a list of characters into a strict (or lazy)  ByteStringWhen writing back to the  ByteString it is assumed that every  lies between 'x00' and 'xff'.  D   (' x D x   (& x D x     ::  %+   ::  )+    Safe-Inferred'(059>?=r optics-extraReturn the the subset of given ordinals within a given bound and in order of the first occurrence seen.Bound:  0 <= x < lordinalNub 3 [-1,2,1,4,2,3][2,1] optics-extrastrict upper bound  optics-extraordinals  optics-extra)unique, in-bound ordinals, in order seen None'(059>?DG  optics-extra sliced i n provides a  that edits the n elements starting at index i from a .This is only a valid 3 if you do not change the length of the resulting .Attempting to return a longer or shorter vector will result in violations of the  laws.Vector.fromList [1..10] ^. sliced 2 5 == Vector.fromList [3,4,5,6,7]True(Vector.fromList [1..10] & sliced 2 5 % mapped .~ 0) == Vector.fromList [1,2,0,0,0,0,0,8,9,10]True optics-extra Similar to , but returning a .(toVectorOf each (8,15) :: Vector.Vector Int) == Vector.fromList [8,15]True optics-extraConvert a list to a  (or back.)([1,2,3] ^. vector :: Vector.Vector Int) == Vector.fromList [1,2,3]True%Vector.fromList [0,8,15] ^. re vector[0,8,15] optics-extra Convert a  to a finite  (or back.) optics-extra Convert a  to a finite  from right to left (or back.) optics-extra Convert a  back and forth to an initializer that when run produces a copy of the . optics-extra Convert a 3 to a version that doesn't retain any extra memory. optics-extraThis = will ignore any duplicates in the supplied list of indices.>toListOf (ordinals [1,3,2,5,9,10]) $ Vector.fromList [2,4..40][4,8,6,12,20,22] optics-extraLike 3$ but polymorphic in the vector type. optics-extra.Indexed vector traversal for a generic vector. optics-extra>Different vector implementations are isomorphic to each other. optics-extrai starting index optics-extran length  None'(059>?Iq optics-extra sliced i n provides a  that edits the n elements starting at index i from a .This is only a valid 3 if you do not change the length of the resulting .Attempting to return a longer or shorter vector will result in violations of the  laws.Vector.fromList [1..10] ^. sliced 2 5 == Vector.fromList [3,4,5,6,7]True(Vector.fromList [1..10] & sliced 2 5 % mapped .~ 0) == Vector.fromList [1,2,0,0,0,0,0,8,9,10]True optics-extra Similar to , but returning a .0toVectorOf each (8,15) == Vector.fromList [8,15]True optics-extraConvert a list to a  (or back),[1,2,3] ^. vector == Vector.fromList [1,2,3]True[1,2,3] ^. vector % re vector[1,2,3]Vector.fromList [0,8,15] ^. re vector % vector == Vector.fromList [0,8,15]True optics-extra Convert a 4 to a version that doesn't retain any extra memory. optics-extraThis = will ignore any duplicates in the supplied list of indices.>toListOf (ordinals [1,3,2,5,9,10]) $ Vector.fromList [2,4..40][4,8,6,12,20,22] optics-extrai starting index optics-extran lengthNone'(059>?KM optics-extra,Wrap a monadic effect. Used when magnifying ,-. optics-extraWrap a monadic effect. optics-extraMake a  out of  for error handling. optics-extraMake a  out of  for error handling. optics-extraUsed by . to / into ,-. optics-extraUsed by . to / into 01.Definitions of indexed optics.None'(059>?L*   !"#$%&')(;)(;'&%$#"!   An  for *2 element of a (potentially monomorphic) container.None'(059>?P  optics-extra * ::       optics-extra * ::       optics-extra * ::       optics-extra * ::       optics-extra * :: ( a,  b) =>   ( a) ( b) a b optics-extra * :: ( a,  b) =>   ( a) ( b) a b optics-extra * :: ( a,  b) =>  Int (23 a) (23 b) a b optics-extra * ::  Int ( a) ( b) a b optics-extra * ::  k ( k a) ( k b) a b+*+* utilities for working with .None'(059>?Vs optics-extraMap over the target(s) of an  in our monadic state.execState (do modifying _1 (*10); modifying _2 $ stimes 5) (6,"o") (60,"ooooo")/execState (modifying each $ stimes 2) ("a","b") ("aa","bb") optics-extra Version of  that is strict in both optic application and state modification.flip evalState ('a','b') $ modifying _1 (errorWithoutStackTrace "oops")()flip evalState ('a','b') $ modifying' _1 (errorWithoutStackTrace "oops")*** Exception: oops optics-extraReplace the target(s) of an  in our monadic state with a new value, irrespective of the old.5execState (do assign _1 'c'; assign _2 'd') ('a','b') ('c','d')%execState (assign each 'c') ('a','b') ('c','c') optics-extra Version of  that is strict in both optic application and state modification.flip evalState ('a','b') $ assign _1 (errorWithoutStackTrace "oops")()flip evalState ('a','b') $ assign' _1 (errorWithoutStackTrace "oops")*** Exception: oops optics-extraUse the target of a , , or  in the current state.evalState (use _1) ('a','b')'a'$evalState (use _2) ("hello","world")"world" optics-extraUse the target of a AffineTraveral or  in the current state.0evalState (preuse $ _1 % _Right) (Right 'a','b')Just 'a'None'(059>?\ optics-extra*Generalized view (even more powerful than view from the lens library).)View the value(s) pointed to by an optic.5The type of the result depends on the optic. You get:Exactly one result a with , ,  and .At most one result Maybe a with ,  and . Monoidal summary of all results  Monoid a => a with  and .When in doubt, use specific, flavour restricted versions. This function is mostly useful for things such as 4. optics-extraUse the target of a , , or . in the current state, or use a summary of a  or ! that points to a monoidal value.evalState (guse _1) ('a','b')'a'%evalState (guse _2) ("hello","world")"world" optics-extraUse the target of a ,  or . in the current state, or use a summary of a  or ! that points to a monoidal value.-evalState (guses _1 length) ("hello","world")5 optics-extraThis is a generalized form of  that only extracts the portion of the log that is focused on by a  . If given a  or a  then a monoidal summary of the parts of the log that are visited will be returned. optics-extraThis is a generalized form of  that only extracts the portion of the log that is focused on by a  . If given a  or a  then a monoidal summary of the parts of the log that are visited will be returned.None'(059>?] optics-extraModify the target of an % returning extra information of type r.+Infix operators for state-modifying optics.None'(059>?d  optics-extraReplace the target(s) of an  in our monadic state with a new value, irrespective of the old.This is an infix version of . optics-extraReplace the target(s) of an  in our monadic state with ' a new value, irrespective of the old. optics-extraMap over the target(s) of an  in our monadic state.This is an infix version of . optics-extraModify the target of an  in the current state returning some extra information of type depending on the optic (r, Maybe r or monoidal summary). optics-extraModify the target of a  into your Monad';s state by a user supplied function and return the result. optics-extraSet  a value with pass-through.This is useful for chaining assignment without round-tripping through your  stack. optics-extraSet with pass-through.This is useful for chaining assignment without round-tripping through your  stack. optics-extraModify the target of a  into your Monad'4s state by a user supplied function and return the old value that was replaced. optics-extraReplace the target of a  into your Monad's state with & a user supplied value and return the old value that was replaced. optics-extraReplace the target of a  into your Monad'3s state with a user supplied value and return the old value that was replaced.   4444444444None'(059>?n optics-extraExtends $ with an ability to magnify using a  over multiple targets so that actions for each one are executed sequentially and the results are aggregated.)There is however no sensible instance of  for StateT. optics-extraThis class allows us to  part of the environment, changing the environment supplied by many different  transformers. Unlike 5 this can change the environment of a deeply nested  transformer.Its functions can be used to run a monadic action in a larger environment than it was defined in, using a  or an .They act like 56, but can in many cases change the type of the environment as well.3They're commonly used to lift actions in a simpler Reader  into a  with a larger environment type.)They can be used to edit pretty much any . transformer stack with an environment in it:(1,2) & magnify _2 (+1)3%flip runReader (1,2) $ magnify _1 ask1=flip runReader (1,2,[10..20]) $ magnifyMaybe (_3 % _tail) ask$Just [11,12,13,14,15,16,17,18,19,20] optics-extraThis class allows us to  in, changing the State supplied by many different monad transformers, potentially quite deep in a monad transformer stack.>Its functions can be used to run a monadic action in a larger State" than it was defined in, using a , an  or a .3This is commonly used to lift actions in a simpler State  into a State  with a larger State type.When used with a  over multiple values, the actions for each target are executed sequentially and the results are aggregated.)This can be used to edit pretty much any  transformer stack with a State in it!3flip L.evalState ('a','b') $ zoom _1 $ use equality'a'6flip S.execState ('a','b') $ zoom _1 $ equality .= 'c' ('c','b')flip L.execState [(1,2),(3,4)] $ zoomMany traversed $ _2 %= (*10)[(1,20),(3,40)]flip S.runState [('a',"b"),('c',"d")] $ zoomMany traversed $ _2 <%= (\x -> x <> x) ("bbdd",[('a',"bb"),('c',"dd")])9flip S.evalState ("a","b") $ zoomMany each (use equality)"ab" optics-extra  =   =   optics-extra  =   2222227None'(059>?n    !"#$%&')(+*,-./1024543768:9;89:89;89<8=>8?@8?A8?B8?C8?D8?E8?F8?G8?H8?I8?JKLMKLNKLOKLPKLQKLRKLSKLTKLUKLVKLWKLXKLYKLZKL[KL\K]^K]_K]`K]aK]bK]cK]dK]eK]fK]gK]hKijKikKlmKlnKloKlpKlqKlrKlsKltKluKlvKlwKlxKyzKy{Ky|K}~                                     4./KKKKKKK+K+KKKKKKKK3K3KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK332KKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKKK}K}K}KKKKKKKKKKKKKKKKKKK'optics-extra-0.4-79mpFziwDHjC7klwbC7pFCOptics.Indexed Optics.Cons Optics.Each Optics.AtData.HashMap.Optics Optics.EmptyData.HashSet.OpticsData.Text.Lazy.OpticsData.Text.Strict.OpticsData.Text.Optics Optics.Extra.Internal.ByteStringData.ByteString.Strict.OpticsData.ByteString.Lazy.OpticsData.ByteString.OpticsOptics.Extra.Internal.VectorData.Vector.Generic.OpticsData.Vector.OpticsOptics.Extra.Internal.Zoom Optics.State Optics.ViewOptics.PassthroughOptics.State.Operators Optics.ZoomData.MapHashMapOptics.Traversal TraversalOptics.Operators^.#Data.Text.Lazymap Data.TextMapData.SetSetData.ByteStringpackunpackData.ByteString.Char8Data.ByteString.LazyData.ByteString.Lazy.Char8 ByteStringControl.Monad.RWSRWSTZoomzoomControl.Monad.StateStateTPrimVector passthroughControl.Monad.Reader.Classlocal Optics.Extra0indexed-traversable-0.1.1-Dw8MIJyvCj8IZQDXOa8TBpData.Foldable.WithIndexitoListifor_ itraverse_Data.Traversable.WithIndexifor WithIndeximapFunctorWithIndexifoldl'ifoldr'ifoldlifoldr ifoldMap'ifoldMapFoldableWithIndex itraverseTraversableWithIndex&optics-core-0.4-LvtBa7lrhQQ5XGfQmCGebVOptics.Cons.Coreunsnocsnoc|>_last_init_tail_headunconscons<|:<:>_ConsCons_SnocSnocOptics.Indexed.Core icomposeN icompose5 icompose4 icompose3icompose reindexed<%%><%>noIxIxOpticOptics.Each.CoreeachEachOptics.At.Coresansat'ixAtIndexcontainsContainsIxValueixIxKindIxedatAtOptics.Empty.CoreEmpty_EmptyAsEmptyOptics.Internal.Indexed conjoinedtoMapOf setmappedsetOfTextpackedunpacked_Textbuildertextutf8IsText $fIsTextText $fIsTextText0 $fIsText[] $fAtHashSet $fAtHashMap$fIxedByteString$fIxedByteString0 $fIxedText $fIxedText0 $fIxedVector $fIxedVector0 $fIxedVector1 $fIxedVector2 $fIxedHashSet $fIxedHashMap$fContainsHashSet$fSnocTextTextCharChar$fSnocTextTextCharChar0$$fSnocByteStringByteStringWord8Word8%$fSnocByteStringByteStringWord8Word80$fSnocVectorVectorab$fSnocVectorVectorab0$fSnocVectorVectorab1$fSnocVectorVectorab2$fConsVectorVectorab$fConsVectorVectorab0$fConsVectorVectorab1$fConsVectorVectorab2$fConsTextTextCharChar$fConsTextTextCharChar0$$fConsByteStringByteStringWord8Word8%$fConsByteStringByteStringWord8Word80 $fAsEmptyText$fAsEmptyText0$fAsEmptyByteString$fAsEmptyByteString0$fAsEmptyVector$fAsEmptyVector0$fAsEmptyVector1$fAsEmptyHashSet$fAsEmptyHashMaptraversedStrictTreetraversedStrictTree8 traversedLazytraversedLazy8CharsBytes packedBytes unpackedBytesbytes packedChars unpackedCharschars IsByteString$fIsByteStringByteString$fIsByteStringByteString0 ordinalNubsliced toVectorOfvectorasStream asStreamRclonedforcedordinalsvectorIxvectorTraverse converted EffectRWS getEffectRWSEffect getEffectErrgetErrMaygetMay FocusingWithunfocusingWithFocusing unfocusing stateZoomstateZoomMaybe stateZoomManyrwsZoom rwsZoomMaybe rwsZoomMany shuffleMay shuffleErr rwsMagnifyrwsMagnifyMayberwsMagnifyManyshuffleSshuffleW$fApplicativeFocusing$fFunctorFocusing$fApplicativeFocusingWith$fFunctorFocusingWith $fMonoidMay$fSemigroupMay $fMonoidErr$fSemigroupErr$fMonoidEffect$fSemigroupEffect$fMonoidEffectRWS$fSemigroupEffectRWS!$fEachInt64ByteStringByteStringab"$fEachInt64ByteStringByteStringab0$fEachIntTextTextab$fEachIntTextTextab0$fEachIntVectorVectorab$fEachIntVectorVectorab0$fEachIntVectorVectorab1$fEachIntVectorVectorab2$fEachkHashMapHashMapab modifying modifying'assignassign'usepreuse ViewableOptic ViewResultgviewgviewsguseguses glistening glistenings$fViewableOpticA_Foldr$fViewableOpticA_Traversalr$fViewableOpticAn_AffineFoldr"$fViewableOpticAn_AffineTraversalr$fViewableOpticA_Prismr$fViewableOpticA_Getterr$fViewableOpticA_ReversedPrismr$fViewableOpticA_Lensr$fViewableOpticAn_IsorPermeableOptic$fPermeableOpticA_Traversalr#$fPermeableOpticAn_AffineTraversalr$fPermeableOpticA_Prismr$fPermeableOpticA_Lensr$fPermeableOpticAn_Isor.=?=%=%%=<%=->ba$fMagnifyManyExceptTExceptTba$fMagnifyManyErrorTErrorTba$fMagnifyManyMaybeTMaybeTba$fMagnifyManyListTListTba$fMagnifyManyWriterTWriterTba$fMagnifyManyWriterTWriterTba0!$fMagnifyManyIdentityTIdentityTba$fMagnifyManyRWSTRWSTba$fMagnifyManyRWSTRWSTba0$fMagnifyManyReaderTReaderTba$fMagnifyMany->->ba Optics.IxFoldIxFold4unordered-containers-0.2.13.0-74JHcjQ66Sy4auaiZwSKzkData.HashMap.InternalunionData.HashSet.InternalHashSet Optics.SetterSetter Optics.Foldfolded text-1.2.3.2Data.Text.Internal.Lazy Optics.Rere Optics.IsoIso traversedsetsbytestring-0.10.10.0Data.ByteString.Lazy.InternalData.Text.InternalisotoStrictData.ByteString.Internal Optics.PrismPrismOptics.IxTraversal IxTraversalbaseGHC.WordWord8Optics.Internal.Optic%ghc-prim GHC.TypesCharGHC.Base.anyOf GHC.Classes==BoolIso'String Optics.LensLens&vector-0.12.2.0-JHTPqJflPVm5AbyFmGf02qData.Vector.Generic.BasetoListOfData.Vector.Fusion.BundleBundle Data.VectorMonoid Data.EitherEither GHC.MaybeMaybeiadjoin isingularipartsOfelement elementOfelements elementsOf ibackwardsindices itraversed ifailover' ifailover iscanr1Of iscanl1Of imapAccumROf imapAccumLOfiforOf itraverseOf itraversalVL IxTraversal' IxTraversalVLIxTraversalVL'Optics.IxSetterimappedisetsiset'isetiover'ioverIxSetter IxSetter' Optics.IxLensisndifstdevoidchosen withIxLensVL toIxLensVLilensVLilensIxLensIxLens'IxLensVL IxLensVL'Optics.IxGetteriviewsiview selfIndexitoIxGetterifindMOfifindOfinoneOfiallOfianyOfilastOfiheadOfifailingisumming ibackwards_ ifilteredipre ifoldringifoldingifoldediforOf_ itraverseOf_ itoListOf ifoldlOf'ifoldrOf ifoldMapOfifoldVLOptics.IxAffineTraversalignoredunsafeFilteredBy iatraverseOf iatraversalVL iatraversalIxAffineTraversalIxAffineTraversal'IxAffineTraversalVLIxAffineTraversalVL'Optics.IxAffineFold iafailing filteredBy iafolding iatraverseOf_ ipreviewsipreviewiafoldVL IxAffineFoldOptics.Internal.Optic.TypesA_LensAn_AffineTraversal A_TraversalA_SetterA_Getter An_AffineFoldA_FoldGHC.IntInt64IntData.Vector.Unboxed.BaseUnboxForeign.StorableStorableData.Vector.Storable'primitive-0.7.1.0-Jxsyd70oUttYiCXCa0HqVData.Primitive.Types mtl-2.2.2Control.Monad.State.Class MonadStateOptic Optics.GetterGetterOptics.AffineFold AffineFoldOptics.ReversedPrism ReversedPrismOptics.AffineTraversalAffineTraversalFoldControl.Monad.Writer.ClasslistenJustMonadLens'AffineTraversal' Traversal'viewspreviews foldMapOf Data.Function& Data.Functor<&>Data.Tuple.Optics_9'_8'_7'_6'_5'_4'_3'_2'_1'Field1_1Field2_2Field3_3Field4_4Field5_5Field6_6Field7_7Field8_8Field9_9Optics.GenericGFieldgfield GAffineFieldgafield GPosition gposition GConstructor gconstructorGPlategplate Optics.Label LabelOptic labelOptic LabelOptic'HasGenericLabelOpticsGenericLabelOpticsadjoinsingularpartsOf backwardsboth failover'failoverscanr1Ofscanl1Of mapAccumROf mapAccumLOf transposeOf sequenceOfforOf traverseOf traversalVL TraversalVL TraversalVL' Optics.ArrowassignA ArrowOpticoverA?!~?~!~.~%!~%~^..^?mappedset'setover'overSetter'Optics.Mapping MappedOptic MappingOpticmapping involutedflipped uncurriedcurriedanonnon'noncoerced1 coercedTocoercedsimpleequalityunderauwithIsoSwappedswapped Optics.ReviewuntoreviewReviewReversedPrism'Optics.ReversedLens ReversedLens ReversedLens'Optics.ReadOnly ReadOnlyOptic ToReadOnlygetting ReversedOpticReversibleOpticData.Either.Optics_Right_LeftData.Maybe.Optics_Just_Nothingnearlyonlybelowwithoutaside withPrismprism'prismPrism'united alongside equality' withLensVLtoLensVLlensVLwithLenslensLensVLLensVL'lookupOffindMOffindOf minimumByOf maximumByOf minimumOf maximumOflengthOf notElemOfelemOfmsumOfasumOfsumOf productOfnoneOfallOforOfandOflastOfheadOfhasn'thasfailingsumming backwards_preunfoldedfoldringfolding sequenceOf_forOf_ traverseOf_foldlOf'foldrOffoldOffoldVLisn'tafailingfilteredafolding atraverseOf_previewafoldVLunsafeFilteredmatching atraverseOf atraversalVLwithAffineTraversal atraversalAffineTraversalVLAffineTraversalVL' Optics.CoercecoerceBcoerceAcoerceTcoerceStoviewAcceptsEmptyIndicesNonEmptyIndicesHasSingleIndex%&%% castOpticOptic'Optics.Internal.Optic.SubtypingIs JoinKinds OpticKindAn_IsoA_PrismA_ReversedPrismA_ReversedLensA_ReviewOptics.Internal.Optic.TypeLevelIxListNoIxWithIxCurry CurryComposecomposeN AppendIndices