h*51F      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                        1.5.1.0  Safe-InferredminiA 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) pairsmini O(n log n)9 Make a map from a list of pairs, combining matching keysmini O(n log n)9 Make a map from a list of pairs, combining matching keysminiO(1) Make a map with a single binmini O(n log m)7 Compose the keys of one set with the values of anothermini O(m log n)+ Subtract a map by another via key matchingmini O(m log n): Subtract a map by another, updating bins of matching keys mini O(m log n): Subtract a map by another, updating bins of matching keys mini O(n log m): Intersect a map with another via left-biased key matching mini O(n log m)? Intersect a map with another by key matching, combining values mini O(n log m)? Intersect a map with another by key matching, combining values mini O(m log n)6 Unite a map with another via left-biased key matchingmini O(m log n)< Unite a map with another, combining values of matching keysmini O(m log n)< Unite a map with another, combining values of matching keysmini7Unite a collection of maps via left-biased key matchingmini=Unite a collection of maps, combining values of matching keysmini=Unite a collection of maps, combining values of matching keysminiO(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 orderminiO(n) Reduce a map with a left-associative operation and an accumulatorminiO(n) Reduce a map with a right-associative operation and an accumulatorminiO(log n)5 Adjust with an operation the value of a key in a mapminiO(log n)5 Adjust with an operation the value of a key in a mapminiO(log n)? Adjust with an operation the value of the maximum key in a mapminiO(log n)? Adjust with an operation the value of the maximum key in a mapminiO(log n)? Adjust with an operation the value of the minimum key in a mapminiO(log n)? Adjust with an operation the value of the minimum key in a mapminiO(log n) Delete a key from a mapminiO(log n)" Delete the maximum key from a mapminiO(log n)" Delete the minimum key from a map mini O(n log n)/ Keep the bins whose values satisfy a predicate!mini O(n log n)8 Keep the bins whose keys and values satisfy a predicate"miniO(log n)> Insert a key and its value into a map, overwriting if present#miniO(log n)= Insert a key and its value, combining new and old if present$miniO(log n)= Insert a key and its value, combining new and old if present%miniO(log n)> Modify the value of a key or delete its bin with an operation&miniO(log n)> Modify the value of a key or delete its bin with an operation'miniO(log n)6 Modify the value of the maximum key or delete its bin(miniO(log n)6 Modify the value of the maximum key or delete its bin)miniO(log n)6 Modify the value of the minimum key or delete its bin*miniO(log n)6 Modify the value of the minimum key or delete its bin+mini O(n log n)' Partition a map with a predicate into  (true, false) submaps,mini O(n log n)' Partition a map with a predicate into  (true, false) submaps-mini O(n log n) Split a map by a key into  (lt, eq, gt) submaps.miniO(log n) Split a map by its maximum key/miniO(log n) Split a map by its minimum key0mini O(m log n). Check whether two maps have no keys in common1mini O(n log m)5 Check whether the bins of one map exist in the other2mini O(n log m)? Check if the bins of one map exist in the other by combination3miniO(log n)' Fetch the value of a key in a map, or  if absent4miniO(log n)3 Fetch the least bin greater than or equal to a key5miniO(log n)0 Fetch the least bin strictly greater than a key6miniO(log n)3 Fetch the greatest bin less than or equal to a key7miniO(log n)0 Fetch the greatest bin strictly less than a key8miniO(log n)( Fetch the bin with the maximum key, or  if empty9miniO(log n)( Fetch the bin with the minimum key, or  if empty:miniO(log n) Check whether a key is in a map;miniO(1) Check whether a map is empty<miniO(n) Get the size of a map=miniO(n)9 Apply an operation across a map, transforming its values>miniO(n)7 Lift a map with a lifting operation on keys and values?miniO(n)> Check whether a map is internally height-balanced and orderedmini Empty binminiLeft-heavy binmini Balanced binminiRight-heavy binminiMap  !"#$%&'()*+,-./0123456789:;<=>?  !"#$%&'()*+,-./0123456789:;<=>? Safe-Inferred!$Hmini"A set containing elements of type a&, internally structured as an AVL treemini Empty nodeminiLeft-heavy nodemini Balanced nodeminiRight-heavy nodeminiPrimitive recursion on setsIminiO(1) The empty setJmini O(n log n)# Make a set from a list of elementsKminiO(1)! Make a set with a single elementLmini O(m log n) Subtract a set by anotherMmini O(m log n) Intersect a set with anotherNmini O(m log n) Unite a set with anotherOminiUnite a collection of setsPminiO(n)6 Turn a set into a list of elements in ascending orderQminiO(n)7 Turn a set into a list of elements in descending orderRminiO(log n) Delete an element from a setSminiO(log n)& Delete the maximum element from a setTminiO(log n)& Delete the minimum element from a setUmini O(n log n)) Keep the elements satisfying a predicateVminiO(log n) Insert an element into a setWmini O(n log n)' Partition a set with a predicate into  (true, false) subsetsXmini O(n log n) Split a set by an element into  (lt, eq, gt) subsetsYminiO(log n)# Split a set by its maximum elementZminiO(log n)# Split a set by its minimum element[mini O(m log n)2 Check whether two sets have no elements in common\mini O(n log m)7 Check whether the elements of a set exist in the other]miniO(log n)? Fetch the least element greater than or equal to the given one^miniO(log n)< Fetch the least element strictly greater than the given one_miniO(log n)? Fetch the greatest element less than or equal to the given one`miniO(log n)< Fetch the greatest element strictly less than the given oneaminiO(log n) Fetch the maximum element, or  if the set is emptybminiO(log n) Fetch the minimum element, or  if the set is emptycminiO(log n)% Check whether an element is in a setdminiO(1) Check whether a set is emptyeminiO(n) Get the size of a setfminiO(n)> Check whether a set is internally height-balanced and orderedmini Empty nodeminiLeft-heavy nodemini Balanced nodeminiRight-heavy nodeminiSetHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefHIJKLMNOPQRSTUVWXYZ[\]^_`abcdef Safe-Inferred#ammini%A reference updating structures from s to t and fields from a to bnmini&Make a lens from a getter and a setteromini5Fetch the field referenced by a lens from a structurepminiUpdate the field referenced by a lens with an operation on a structureqminiOverwrite the field referenced by a lens with a value on a structuremnopqmnopq Safe-Inferred$Trmini,Instances should satisfy the following laws: lift . pure = pure &lift (m >>= f) = lift m >>= (lift . f)sminiLift a computation from the inner monad to the transformer monadrsrs Safe-Inferred%gtmini*A terminable transformer with termination e, inner monad m , return avmini Unwrap an t computationwmini&Terminate the computation with a valuexmini$Run a computation and get its resulttuvwxtuvwx Safe-Inferred&qmini*A terminable transformer with inner monad m , return amini Unwrap a  computationmini)Terminate the computation without a valuemini$Run a computation and get its result Safe-Inferred-Kmini A parse errorminiA transformer parsing symbols s, inner monad m , return amini Unwrap a 0 computation with a sequence of symbols to parsemini$Parse symbols satisfying a predicateminiParse any symbolminiParse a symbolminiParse a sequence of symbolsmini&Parse symbols included in a collectionmini(Parse symbols excluded from a collectionmini'Parse successfully only at end of inputmini*Parse the next symbol without consuming itminiParse zero or more p separated by q via  p `sepBy` qminiParse one or more p separated by q via  p `sepBy1` qminiParse zero or more p until q succeeds via  p `till` qminiParse one or more p left-associatively chained by f via  chainl1 p fminiParse one or more p right-associatively chained by f via  chainr1 p fminiParse p enclosed by a and b via  between a b pminiParse p returning a in case of failure via  option a pminiParse p, without consuming input, iff p fails via reject pminiParse p, without consuming input, iff p succeeds via accept pmini%Find and parse the first instance of p via  findFirst pmini$Find and parse the last instance of p via  findLast pmini,Prepend an error message to that of a parserminiCombine the results of p and q via p <> qminiParse p or, if p fails, backtrack and parse q via p <|> q Safe-Inferred.miniA transformer with read-only r, inner monad m , return amini Unwrap a , computation with an initial read-only valueminiFetch the read-only environmentmini+Run a computation in a modified environment  Safe-Inferred02miniA 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-Inferred12mini'A transformer with monoidal write-only w, inner monad m , return amini Unwrap a  computationmini,Append a value to the write-only environment   !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRST  )*+,.79:;<U@ABCDEFGHKVWXYZ[\]^_`abccdefghijklmnnopfqrstuvwxxyzz{|}~                        `#mini-1.5.1.0-1NFErx8tcY6HHUxITNKIuU Mini.Data.Map Mini.Data.SetMini.Optics.LensMini.Transformers.ClassMini.Transformers.EitherTMini.Transformers.MaybeTMini.Transformers.ParserTMini.Transformers.ReaderTMini.Transformers.StateTMini.Transformers.WriterTminiMapemptyfromList fromListWithfromListWithKey singletoncompose differencedifferenceWithdifferenceWithKey intersectionintersectionWithintersectionWithKeyunion unionWith unionWithKeyunions unionsWith unionsWithKey toAscList toDescList foldlWithKey foldrWithKeyadjust adjustWithKey adjustMaxadjustMaxWithKey adjustMinadjustMinWithKeydelete deleteMax deleteMinfilter filterWithKeyinsert insertWith insertWithKeyupdate updateWithKey updateMaxupdateMaxWithKey updateMinupdateMinWithKey partitionpartitionWithKeysplitsplitMaxsplitMindisjoint isSubmapOf isSubmapOfBylookuplookupGElookupGTlookupLElookupLT lookupMax lookupMinmembernullsize fmapWithKeytraverseWithKeyvalid $fMonoidMap$fSemigroupMap$fTraversableMap $fFoldableMap $fFunctorMap $fShowMap$fOrdMap$fEqMapSet isSubsetOf $fMonoidSet$fSemigroupSet $fFoldableSet $fShowSet$fOrdSet$fEqSetLenslensviewoverset MonadTransliftEitherT runEitherTleft anticipate$fMonadIOEitherT$fMonadFailEitherT$fMonadTransEitherT$fMonadEitherT$fAlternativeEitherT$fApplicativeEitherT$fFunctorEitherTMaybeT runMaybeTnothing$fMonadIOMaybeT$fMonadFailMaybeT$fMonadTransMaybeT $fMonadMaybeT$fAlternativeMaybeT$fApplicativeMaybeT$fFunctorMaybeT ParseError unexpectedParserT runParserTsatitemsymbolstringoneOfnoneOfeofpeeksepBysepBy1tillchainl1chainr1betweenoptionrejectaccept findFirstfindLastannotate$fMonadIOParserT$fMonadFailParserT$fMonoidParserT$fSemigroupParserT$fMonadTransParserT$fMonadParserT$fAlternativeParserT$fApplicativeParserT$fFunctorParserT$fShowParseErrorReaderT runReaderTasklocal$fMonadIOReaderT$fMonadFailReaderT$fMonadTransReaderT$fMonadReaderT$fAlternativeReaderT$fApplicativeReaderT$fFunctorReaderTStateT runStateTgetmodifyput$fMonadIOStateT$fMonadFailStateT$fMonadTransStateT $fMonadStateT$fAlternativeStateT$fApplicativeStateT$fFunctorStateTWriterT runWriterTtell$fMonadIOWriterT$fMonadFailWriterT$fMonadTransWriterT$fMonadWriterT$fAlternativeWriterT$fApplicativeWriterT$fFunctorWriterTELBRmapbase GHC.MaybeNothing