h*(]%      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnop q r s t u v w 1.0.0.0  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).xmini Empty binyminiLeft-heavy binzmini Balanced bin{miniRight-heavy bin|miniPrimitive 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 ordered|mini 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 purely functional reference for updating structures of type s with fields of type a to structures of type t with fields of type b:mini$From a getter and a setter to a lens data Foo = Foo { _bar :: Bar } deriving Show data Bar = Bar { _baz :: Int } deriving Show bar :: Lens Foo Foo Bar Bar bar = lens _bar $ \s b -> s { _bar = b } baz :: Lens Bar Bar Int Int baz = lens _baz $ \s b -> s { _baz = b };miniFrom a lens and a structure to the value of the field of the structure referenced by the lens (ghci> view (bar . baz) $ Foo (Bar 73) 73<miniFrom a lens, an operation and a structure to the structure updated by applying the operation to the value of the field referenced by the lens ghci> over (bar . baz) (+ 1) $ Foo (Bar 73) Foo {_bar = Bar {_baz = 74}}=miniFrom a lens, a value and a structure to the structure updated by setting the field referenced by the lens to the value ghci> set (bar . baz) 21 $ Foo (Bar 73) Foo {_bar = Bar {_baz = 21}}9:;<=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-Inferred@mini$A monad with early termination type e, inner monad m, and return type aAmini Unwrap an @Bmini1Terminate an action sequence with the given valueCminiRun the given action and decide what to do depending on the return type !anticipate foo >>= either bar baz@ABC@BCA Safe-Inferred"+Imini=Abstract representation of a parse error for symbols of type sJmini$A monad for parsing symbols of type s with inner monad m and return type aKmini Unwrap a J given a string of symbolsLminiFrom a predicate to a parser for symbols satisfying the predicate digit = sat Data.Char.isDigit spaces = Control.Applicative.many $ sat Data.Char.isSpaceMminiA parser for any symbolNminiA parser for the given symbolOmini(A parser for the given string of symbolsPmini%A parser for any of the given symbolsQmini3A parser for any symbol excluding the given symbolsRminiTurn a parser and another parser into a parser for zero or more of the former separated by the latterSminiTurn a parser and another parser into a parser for one or more of the former separated by the latterTminiTurn a parser and another parser into a parser for zero or more of the former separated and ended by the latterUminiTurn a parser and another parser into a parser for one or more of the former separated and ended by the latterVminiTurn a first, second and third parser into a parser for the third enclosed between the first and the second, returning the result of the thirdWminiFrom a default value and a parser to the parser returning the default value in case of failureJKILMNOPQRSTUVWJIKLMNOPQRSTUVW Safe-Inferred#A^miniA monad with read-only type r, inner monad m, and return type a_mini Unwrap a ^ given a read-only value`miniFetch the read-only value foo = do r <- ask bar r^_`^`_ Safe-Inferred$fminiA monad with modifiable type s, inner monad m, and return type agmini Unwrap a f given a starting statehmini$Fetch the current value of the state foo = do s <- get bar simini>Update the current value of the state with the given operation foo = modify $ \s -> bar sjmini Set the state to the given valuefghijfhijg  Safe-Inferred%pmini&A monad with monoidal write-only type w, inner monad m, and return type aqmini Unwrap a prmini$Append the given value to the outputpqrprq    !"#$%&'()*+,-  . !"$/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi j k l m n o p qrstuvwxywxzrstu7#mini-1.0.0.0-1n0woKzzcmqHRe11nee3RE Mini.Data.Map Mini.Data.Set Mini.LensMini.Transformers.ClassMini.Transformers.EitherTMini.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$fFunctorEitherT ParseErrorParserT runParserTsatitemsymbolstringoneOfnoneOfsepBysepBy1endByendBy1betweenoption$fShowParseError$fMonadTransParserT$fMonadParserT$fAlternativeParserT$fApplicativeParserT$fFunctorParserTReaderT runReaderTask$fMonadTransReaderT$fMonadReaderT$fAlternativeReaderT$fApplicativeReaderT$fFunctorReaderTStateT runStateTgetmodifyput$fMonadTransStateT $fMonadStateT$fAlternativeStateT$fApplicativeStateT$fFunctorStateTWriterT runWriterTtell$fMonadTransWriterT$fMonadWriterT$fAlternativeWriterT$fApplicativeWriterT$fFunctorWriterTELBRmapbase GHC.MaybeJustNothing