h*/,      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    1.2.2.1  Safe-InferredminiA map from keys of type k to values of type a.The internal structure is an AVL tree; a tree that is always height-balanced (the absolute value of the level difference between the left and right subtrees is at most 1).mini Empty binminiLeft-heavy binmini Balanced binminiRight-heavy binminiPrimitive recursion on mapsmini O(n \log n)' Map difference (matching only on keys)mini O(n \log n)5 Left-biased map intersection (matching only on keys)mini O(n \log n). Left-biased map union (matching only on keys)miniO(1) The empty mapmini O(n \log n) From a tail-biased list of  (key, value)8 pairs to a map with bins containing the keys and valuesminiO(1)2 From a key and a value to a map with a single binminiO(n) From a map to a list of  (key, value) pairs in key-ascending orderminiO(n) From a map to a list of  (key, value) pairs in key-descending order miniO(n) From a left-associative operation on keys and values, a starting accumulator and a map to a thing miniO(n) From a right-associative operation on keys and values, a starting accumulator and a map to a thing mini O(\log n) From an operation, a key and a map to the map adjusted by applying the operation to the value associated with the key mini O(\log n)0 From a key and a map to the map without the key miniO(n) From a predicate and a map to the map with values satisfying the predicateminiO(n) From a predicate and a map to the map with keys and values satisfying the predicatemini O(\log n) From a key, a value and a map to the map including a bin containing the key and the valuemini O(\log n) From an operation, a key and a map to the map updated by applying the operation to the value associated with the key (setting if , deleting if )mini O(n \log n) From a map and another map to whether the former is a submap of the latter (matching on keys and values)mini O(\log n) From a key and a map to the value associated with the key in the mapmini O(\log n) From a map to the value associated with the maximum key in the mapmini O(\log n) From a map to the value associated with the minimum key in the mapmini O(\log n)6 From a key and a map to whether the key is in the mapminiO(1)' From a map to whether the map is emptyminiO(n)" From a map to the size of the mapminiO(n) From a lifting operation on keys and values and a map to a lifted mapminiO(n) From a map to whether its internal structure is valid, i.e. height-balanced and orderedmini Empty binminiLeft-heavy bin: left child, key, value, right child, left recursion, right recursionminiBalanced bin: left child, key, value, right child, left recursion, right recursionminiRight-heavy bin: left child, key, value, right child, left recursion, right recursionminiMap   Safe-Inferred"mini"A set containing elements of type a.The internal structure is an AVL tree; a tree that is always height-balanced (the absolute value of the level difference between the left and right subtrees is at most 1).mini Empty nodeminiLeft-heavy nodemini Balanced nodeminiRight-heavy nodeminiPrimitive recursion on sets#mini O(n \log n) Set difference$mini O(n \log n) Set intersection%mini O(n \log n) Set union&miniO(1) The empty set'mini O(n \log n) From a tail-biased list of elements to a set containing the elements(miniO(1)/ From an element to a set with a single element)miniO(n)4 From a set to a list of elements in ascending order*miniO(n)5 From a set to a list of elements in descending order+mini O(\log n)9 From an element and a set to the set without the element,miniO(n) From a predicate and a set to the set with elements satisfying the predicate-mini O(\log n); From an element and a set to the set including the element.mini O(n \log n) From a set and another set to whether the former is a subset of the latter/mini O(\log n)- From a set to the maximum element of the set0mini O(\log n)- From a set to the minimum element of the set1mini O(\log n)? From an element and a set to whether the element is in the set2miniO(1)' From a set to whether the set is empty3miniO(n)" From a set to the size of the set4miniO(n) From a set to whether its internal structure is valid, i.e. height-balanced and orderedmini Empty nodeminiLeft-heavy node: left child, element, right child, left recursion, right recursionminiBalanced node: left child, element, right child, left recursion, right recursionminiRight-heavy node: left child, element, right child, left recursion, right recursionminiSet"#$%&'()*+,-./01234"#$%&'()*+,-./01234 Safe-InferredS9mini%A reference updating structures from s to t and fields from a to b:mini&Make a lens from a getter and a setter;mini5Fetch the field referenced by a lens from a structure<miniUpdate the field referenced by a lens with an operation on a structure=miniOverwrite the field referenced by a lens with a value on a structure9:;<=9:;<= Safe-InferredF>mini,Instances should satisfy the following laws: lift . pure = pure &lift (m >>= f) = lift m >>= (lift . f)?miniLift a computation from the inner monad to the transformer monad>?>? Safe-InferredY@mini*A terminable transformer with termination e, inner monad m , return aBmini Unwrap an @ computationCmini&Terminate the computation with a valueDmini$Run a computation and get its result@ABCD@ABCD Safe-Inferred^Jmini*A terminable transformer with inner monad m , return aLmini Unwrap a J computationMmini)Terminate the computation without a valueNmini$Run a computation and get its resultJKLMNJKLMN Safe-Inferred(Tmini(Abstract representation of a parse errorUminiA transformer parsing symbols s, inner monad m , return aWmini Unwrap a U0 computation with a sequence of symbols to parseXmini$Parse symbols satisfying a predicateExamples(runParserT (some $ sat isDigit) "123abc"Right ("123","abc")YminiParse any symbolExamples'runParserT (item *> item <* item) "bar"Right ('a',"")ZminiParse a symbolExamplesrunParserT (symbol 'f') "foo"Right ('f',"oo")[miniParse a sequence of symbolsExamples"runParserT (string "foo") "foobar"Right ("foo","bar")\mini&Parse symbols included in a collectionExamplesrunParserT (oneOf "abc") "bar"Right ('b',"ar")]mini(Parse symbols excluded from a collectionExamplesrunParserT (noneOf "abc") "foo"Right ('f',"oo")^mini'Parse successfully only at end of inputExamples,runParserT (string "foobar" *> eof) "foobar" Right ((),"")_miniParse zero or more p separated by q via  p `sepBy` qExamples8runParserT (sat isDigit `sepBy` symbol ',') "1,2,3,four"Right ("123",",four")`miniParse one or more p separated by q via  p `sepBy1` qExamples9runParserT (sat isDigit `sepBy1` symbol ',') "1,2,3,four"Right ("123",",four")aminiParse zero or more p separated and ended by q via  p `endBy` qExamples8runParserT (sat isDigit `endBy` symbol ',') "1,2,3,four"Right ("123","four")bminiParse one or more p separated and ended by q via  p `endBy1` qExamples9runParserT (sat isDigit `endBy1` symbol ',') "1,2,3,four"Right ("123","four")cminiParse zero or more p left-chained with op atop a via  chainl p op aExamplesrunParserT (chainl (read <$> some (sat isDigit)) ((+) <$ item) 10) "2a3b4c" Right (9,"c")dminiParse one or more p left-chained with op via  chainl1 p opExamplesrunParserT (chainl1 (read <$> some (sat isDigit)) ((+) <$ item)) "2a3b4c" Right (9,"c")eminiParse zero or more p right-chained with op atop a via  chainr p op aExamplesrunParserT (chainr (read <$> some (sat isDigit)) ((*) <$ item) 10) "2a3b4c"Right (24,"c")fminiParse one or more p right-chained with op via  chainr1 p opExamplesrunParserT (chainr1 (read <$> some (sat isDigit)) ((*) <$ item)) "2a3b4c"Right (24,"c")gminiParse p enclosed by a and b via  between a b pExamplesrunParserT (between (symbol '(') (symbol ')') (many $ sat isLetter)) "(yes)"Right ("yes","")hminiParse p returning a in case of failure via  option a pExamples.runParserT (option "foo" $ string "bar") "baz"Right ("foo","baz")iminiParse p, without consuming input, iff p fails via reject pExamples=runParserT (string "foo" <* reject (sat isLetter)) "foo(bar)"Right ("foo","(bar)")jminiParse p, without consuming input, iff p succeeds via accept pExamples2runParserT (accept item >>= pure . (== 'a')) "foo"Right (False,"foo")nminiCombine the results of p and q via p <> qqminiParse p or, if p fails, backtrack and parse q via p <|> qUVWTXYZ[\]^_`abcdefghijUVTWXYZ[\]^_`abcdefghij Safe-Inferred*IvminiA transformer with read-only r, inner monad m , return axmini Unwrap a v, computation with an initial read-only valueyminiFetch the read-only environmentzmini+Run a computation in a modified environmentvwxyzvwxyz  Safe-Inferred+miniA transformer with state s, inner monad m , return amini Unwrap a " computation with an initial stateminiFetch the current statemini*Update the current state with an operationmini(Overwrite the current state with a value  Safe-Inferred,mini'A transformer with monoidal write-only w, inner monad m , return amini Unwrap a  computationmini,Append a value to the write-only environment   !"#$%&'()*+,-. / !"#%0123456789:;;<=>?@ABCDDEF>GHIJKLMMNOPQRSTUVWXYZ[\]^_`abcdefghijklmmnopqrstu v v w x y z { | } ~          8#mini-1.2.2.1-LrDAiImi6K51jckDB9n7Oi Mini.Data.Map Mini.Data.SetMini.Optics.LensMini.Transformers.ClassMini.Transformers.EitherTMini.Transformers.MaybeTMini.Transformers.ParserTMini.Transformers.ReaderTMini.Transformers.StateTMini.Transformers.WriterTminiMap difference intersectionunionemptyfromList singleton toAscList toDescList foldlWithKey foldrWithKeyadjustdeletefilter filterWithKeyinsertupdate isSubmapOflookup lookupMax lookupMinmembernullsizetraverseWithKeyvalid $fMonoidMap$fSemigroupMap$fTraversableMap $fFoldableMap $fFunctorMap $fShowMap$fEqMap$fOrdMapSet isSubsetOf $fFoldableSet $fShowSet$fEqSet$fOrdSetLenslensviewoverset MonadTransliftEitherT runEitherTleft anticipate$fMonadTransEitherT$fMonadEitherT$fAlternativeEitherT$fApplicativeEitherT$fFunctorEitherTMaybeT runMaybeTnothing$fMonadTransMaybeT $fMonadMaybeT$fAlternativeMaybeT$fApplicativeMaybeT$fFunctorMaybeT ParseErrorParserT runParserTsatitemsymbolstringoneOfnoneOfeofsepBysepBy1endByendBy1chainlchainl1chainrchainr1betweenoptionrejectaccept$fShowParseError$fMonadFailParserT$fMonoidParserT$fSemigroupParserT$fMonadTransParserT$fMonadParserT$fAlternativeParserT$fApplicativeParserT$fFunctorParserT$fSemigroupParseError$fMonoidParseErrorReaderT runReaderTasklocal$fMonadTransReaderT$fMonadReaderT$fAlternativeReaderT$fApplicativeReaderT$fFunctorReaderTStateT runStateTgetmodifyput$fMonadTransStateT $fMonadStateT$fAlternativeStateT$fApplicativeStateT$fFunctorStateTWriterT runWriterTtell$fMonadTransWriterT$fMonadWriterT$fAlternativeWriterT$fApplicativeWriterT$fFunctorWriterTELBRmapbase GHC.MaybeJustNothing