h*"uQ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                    1.4.0.2  Safe-Inferred miniA map from keys k to values a&, internally structured as an AVL treemini Empty binminiLeft-heavy binmini Balanced binminiRight-heavy binminiPrimitive recursion on mapsminiO(1) The empty mapmini O(n log n)' Make a map from a tail-biased list of  (key, value) pairsminiO(1) Make a map with a single binmini O(n log n)+ Subtract a map by another via key matchingmini O(n log n): Intersect a map with another via left-biased key matchingmini O(n log n)6 Unite a map with another via left-biased key matchingminiO(n) Turn a map into a list of  (key, value) pairs in ascending orderminiO(n) Turn a map into a list of  (key, value) pairs in descending order miniO(n) Reduce a map with a left-associative operation and an accumulator miniO(n) Reduce a map with a right-associative operation and an accumulator miniO(log n)5 Adjust with an operation the value of a key in a map miniO(log n) Delete a key from a map miniO(n)/ Keep the bins whose values satisfy a predicateminiO(n)8 Keep the bins whose keys and values satisfy a predicateminiO(log n)> Insert a key and its value into a map, overwriting if presentminiO(log n)> Modify the value of a key or delete its bin with an operationmini O(n log n)5 Check whether the bins of one map exist in the otherminiO(log n)' Fetch the value of a key in a map, or  if absentminiO(log n)( Fetch the bin with the maximum key, or  if emptyminiO(log n)( Fetch the bin with the minimum key, or  if emptyminiO(log n) Check whether a key is in a mapminiO(1) Check whether a map is emptyminiO(n) Get the size of a mapminiO(n)7 Lift a map with a lifting operation on keys and valuesminiO(n)> Check whether a map is internally height-balanced and orderedmini Empty binminiLeft-heavy binmini Balanced binminiRight-heavy binminiMap   Safe-Inferred"mini"A set containing elements of type a&, internally structured as an AVL treemini Empty nodeminiLeft-heavy nodemini Balanced nodeminiRight-heavy nodeminiPrimitive recursion on sets#miniO(1) The empty set$mini O(n log n)# Make a set from a list of elements%miniO(1)! Make a set with a single element&mini O(n log n) Subtract a set by another'mini O(n log n) Intersect a set with another(mini O(n log n) Unite a set with another)miniO(n)6 Turn a set into a list of elements in ascending order*miniO(n)7 Turn a set into a list of elements in descending order+miniO(log n) Delete an element from a set,miniO(n)) Keep the elements satisfying a predicate-miniO(log n) Insert an element into a set.mini O(n log n)7 Check whether the elements of a set exist in the other/miniO(log n) Fetch the maximum element, or  if the set is empty0miniO(log n) Fetch the minimum element, or  if the set is empty1miniO(log n)% Check whether an element is in a set2miniO(1) Check whether a set is empty3miniO(n) Get the size of a set4miniO(n)> Check whether a set is internally height-balanced and orderedmini Empty nodeminiLeft-heavy nodemini Balanced nodeminiRight-heavy nodeminiSet"#$%&'()*+,-./01234"#$%&'()*+,-./01234 Safe-Inferred9mini%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-Inferred>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 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-InferredJmini*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-InferredTmini A parse errorWminiA transformer parsing symbols s, inner monad m , return aYmini Unwrap a W0 computation with a sequence of symbols to parseZmini$Parse symbols satisfying a predicate[miniParse any symbol\miniParse a symbol]miniParse a sequence of symbols^mini&Parse symbols included in a collection_mini(Parse symbols excluded from a collection`mini'Parse successfully only at end of inputamini*Parse the next symbol without consuming itbminiParse zero or more p separated by q via  p `sepBy` qcminiParse one or more p separated by q via  p `sepBy1` qdminiParse zero or more p until q succeeds via  p `till` qeminiParse one or more p left-associatively chained by f via  chainl1 p ffminiParse one or more p right-associatively chained by f via  chainr1 p fgminiParse p enclosed by a and b via  between a b phminiParse p returning a in case of failure via  option a piminiParse p, without consuming input, iff p fails via reject pjminiParse p, without consuming input, iff p succeeds via accept pmminiCombine the results of p and q via p <> qpminiParse p or, if p fails, backtrack and parse q via p <|> qWXYTUVZ[\]^_`abcdefghijWXTUVYZ[\]^_`abcdefghij Safe-InferredtminiA transformer with read-only r, inner monad m , return avmini Unwrap a t, computation with an initial read-only valuewminiFetch the read-only environmentxmini+Run a computation in a modified environmenttuvwxtuvwx  Safe-InferredA~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>GHIJKLLMNNOPQRSTUVWXYZ[\]^_`abcdefghijjklmnopqr s s t u v w x y z { | } } ~      8#mini-1.4.0.2-4XSD1qvHTW42kMCdIYC55P Mini.Data.Map Mini.Data.SetMini.Optics.LensMini.Transformers.ClassMini.Transformers.EitherTMini.Transformers.MaybeTMini.Transformers.ParserTMini.Transformers.ReaderTMini.Transformers.StateTMini.Transformers.WriterTminiMapemptyfromList singleton difference intersectionunion 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 ParseError unexpectedParserT runParserTsatitemsymbolstringoneOfnoneOfeofpeeksepBysepBy1tillchainl1chainr1betweenoptionrejectaccept$fMonadFailParserT$fMonoidParserT$fSemigroupParserT$fMonadTransParserT$fMonadParserT$fAlternativeParserT$fApplicativeParserT$fFunctorParserT$fShowParseErrorReaderT runReaderTasklocal$fMonadTransReaderT$fMonadReaderT$fAlternativeReaderT$fApplicativeReaderT$fFunctorReaderTStateT runStateTgetmodifyput$fMonadTransStateT $fMonadStateT$fAlternativeStateT$fApplicativeStateT$fFunctorStateTWriterT runWriterTtell$fMonadTransWriterT$fMonadWriterT$fAlternativeWriterT$fApplicativeWriterT$fFunctorWriterTELBRmapbase GHC.MaybeNothing