úÎ9Ûà      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…† ‡ ˆ ‰ Š ‹ Œ Ž ‘ ’ “ ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á  SafeV AÃNone DFQTV ÎÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÄÓNoneFQTVƒO(1)) Create a diet map with a single element.O(log n)& Lookup the value at a key in the map.inclusive lower boundinclusive upper boundvalueexpected size of resulting key-value pairsexpected size of resulting key-value pairsÔNoneFQTV3 O(1)) Create a diet map with a single element.O(log n)& Lookup the value at a key in the map. inclusive lower boundinclusive upper boundvalueexpected size of resulting  key-value pairsexpected size of resulting  key-value pairs   ÕSafe¬NoneFQTVÖlower inclusive boundupper inclusive bound×lower inclusive boundupper inclusive boundØinclusive lower boundinclusive upper boundÙinclusive lower boundÚexclusive lower boundÛinclusive upper boundÜexclusive upper boundÝÞßàáâÖãäåæçØÙÚÛÜèéêëìíÝîNoneFQTV'MO(1)) Create a diet set with a single element.O(log n) Returns True, if the element is a member of the diet set.O(n + m*log n)! Subtract the subtrahend of size m from the minuend of size nK. It should be possible to improve the improve the performance of this to O(n + m)4. Anyone interested in doing this should open a PR.O(n)N The subset where all elements are greater than or equal to the given value. O(n)K The subset where all elements are less than or equal to the given value. !O(n)x The subset where all elements are greater than or equal to the lower bound and less than or equal to the upper bound.inclusive lower boundinclusive upper bound expected size of resulting diet key-value pairsminuend subtrahendinclusive lower bound inclusive upper bound!inclusive lower boundinclusive upper bound  !  !ïNoneFQTV53)O(1)) Create a diet set with a single element.*O(log n)& Lookup the value at a key in the map..O(n + m*log n)! Subtract the subtrahend of size m from the minuend of size nK. It should be possible to improve the improve the performance of this to O(n + m)4. Anyone interested in doing this should open a PR.0O(n)N The subset where all elements are greater than or equal to the given value. 1O(n)K The subset where all elements are less than or equal to the given value. 2O(n)x The subset where all elements are greater than or equal to the lower bound and less than or equal to the upper bound.)inclusive lower boundinclusive upper bound- expected size of resulting diet (key-value pairs.minuend subtrahend0inclusive lower bound1inclusive upper bound2inclusive lower boundinclusive upper bound ()*+,-./012 ()*.012/+,-(ðNoneFQTV7wñlower inclusive bound, Nothing means -"upper inclusive bound, Nothing means +"òóôñõö÷òøùNoneFQTV;:O(1)4 Create an unbounded diet set with a single element.;O(log n) Returns True, if the element is a member of the diet set.:lower inclusive bound, Nothing means -"upper inclusive bound, Nothing means +"9:;9:;9úNone DFQTV?¥ûO(n)/ Drop elements for which the predicate returns ü.ý¤Sort and deduplicate the key array, preserving the last value associated with each key. The argument arrays may not be reused after being passed to this function.þÿû     ýþNoneFQTVgŠ@A map from keys k to values v4. The key type and the value type must both have Prim instances.AO(log n)& Lookup the value at a key in the map.BO(1)$ Create a map with a single element.C O(n*log n)× Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.D O(n*log n)( This function has the same behavior as CÎ regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the @S. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.E O(n*log n)( This function has the same behavior as C#, but it combines values with the 4 instances instead of choosing the last occurrence.F O(n*log n)( This function has the same behavior as D#, but it combines values with the 4 instances instead of choosing the last occurrence.GO(1)# The number of elements in the map.HO(n) Map over the values in the map.IO(n)/ Drop elements for which the predicate returns ü.JO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.KO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.LO(n)£ Monadic left fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the left after each reduction.MO(n)¥ Monadic right fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the right after each reduction.NO(n)ù Fold over the keys and values of the map with a strict monoidal accumulator. This function does not have left and right variants since the associativity required by a monoid instance means that both variants would always produce the same result.OO(n)> Left fold over the keys and values with a strict accumulator.PO(n)? Right fold over the keys and values with a strict accumulator. Dexpected size of resulting @key-value pairsFexpected size of resulting @key-value pairsJ reductioninitial accumulatormapK reductioninitial accumulatormapL reductionmapM reductionmapN reduction mapO reductioninitial accumulatormapP reductioninitial accumulatormap@ABCDEFGHIJKLMNOP@BAGHIOPNJKLMCEDF@NoneFQTV”ÜWA map from keys k to values v. The key type must have a . instance and the value type is unconstrained.XO(log n)& Lookup the value at a key in the map.YO(1)$ Create a map with a single element.Z O(n*log n)× Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.[ O(n*log n)( This function has the same behavior as ZÎ regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the WS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.\ O(n*log n)( This function has the same behavior as Z#, but it combines values with the 4 instances instead of choosing the last occurrence.] O(n*log n)( This function has the same behavior as [#, but it combines values with the 4 instances instead of choosing the last occurrence.^O(1)# The number of elements in the map._O(n) Map over the values in the map.`O(n)/ Drop elements for which the predicate returns ü.aO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.bO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.cO(n)£ Monadic left fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the left after each reduction.dO(n)¥ Monadic right fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the right after each reduction.eO(n)ù Fold over the keys and values of the map with a strict monoidal accumulator. This function does not have left and right variants since the associativity required by a monoid instance means that both variants would always produce the same result.f O(n*log n)ÿE Zip an array of keys with an array of values. If they are not the same length, the longer one will be truncated to match the shorter one. This function sorts and deduplicates the array of keys, preserving the last value associated with each key. The argument arrays may not be reused after being passed to this function.»This is by far the fastest way to create a map, since the functions backing it are aggressively specialized. It internally uses a hybrid of mergesort and insertion sort provided by the primitive-sort: package. It generates much less garbage than any of the fromList variants. m1This fails the functor laws since fmap is strict.[expected size of resulting Wkey-value pairs]expected size of resulting Wkey-value pairsd reductionmapWXYZ[\]^_`abcdefWYX^_`eabcdZ\[]fWNoneFQTVÆ„nA map from keys k to values v4. The key type and the value type must both have  instances.oO(log n)& Lookup the value at a key in the map.pO(1)$ Create a map with a single element.q O(n*log n)× Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.r O(n*log n)( This function has the same behavior as qÎ regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the nS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.s O(n*log n)( This function has the same behavior as q#, but it combines values with the 4 instances instead of choosing the last occurrence.t O(n*log n)( This function has the same behavior as r#, but it combines values with the 4 instances instead of choosing the last occurrence.uO(1)# The number of elements in the map.vO(n) Map over the values in the map.wO(n)/ Drop elements for which the predicate returns ü.xO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.yO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.zO(n)£ Monadic left fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the left after each reduction.{O(n)¥ Monadic right fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the right after each reduction.|O(n)ù Fold over the keys and values of the map with a strict monoidal accumulator. This function does not have left and right variants since the associativity required by a monoid instance means that both variants would always produce the same result.}O(n)> Left fold over the keys and values with a strict accumulator.~O(n)? Right fold over the keys and values with a strict accumulator. O(n*log n)ÿE Zip an array of keys with an array of values. If they are not the same length, the longer one will be truncated to match the shorter one. This function sorts and deduplicates the array of keys, preserving the last value associated with each key. The argument arrays may not be reused after being passed to this function.»This is by far the fastest way to create a map, since the functions backing it are aggressively specialized. It internally uses a hybrid of mergesort and insertion sort provided by the primitive-sort: package. It generates much less garbage than any of the fromList variants. rexpected size of resulting nkey-value pairstexpected size of resulting nkey-value pairsx reductioninitial accumulatormapy reductioninitial accumulatormapz reductionmap{ reductionmap| reduction map} reductioninitial accumulatormap~ reductioninitial accumulatormapnopqrstuvwxyz{|}~npouvw}~|xyz{qsrtn NoneFQTVÚƆA map from keys k to values v4. The key type and the value type must both have  instances.‡O(log n)& Lookup the value at a key in the map.ˆO(1)$ Create a map with a single element.‰ O(n*log n)× Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.Š O(n*log n)( This function has the same behavior as ‰Î regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the †S. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.‹ O(n*log n)( This function has the same behavior as ‰#, but it combines values with the 4 instances instead of choosing the last occurrence.Œ O(n*log n)( This function has the same behavior as Š#, but it combines values with the 4 instances instead of choosing the last occurrence.O(1)# The number of elements in the map.Šexpected size of resulting †key-value pairsŒexpected size of resulting †key-value pairs†‡ˆ‰Š‹Œ†ˆ‡‰‹ŠŒ†None DFQTVÛ— !"#$%&'()*+,-./NoneDFQTVà••CConvert a set to a list. The elements are given in ascending order.–Convert a list to a set.—IRight fold over the elements in the set. This is lazy in the accumulator.˜.Strict left fold over the elements in the set.™/Strict right fold over the elements in the set.”01•–—˜™”01 NoneDFQTVääšThe difference of two sets.›Infix operator for š.œ3Test whether or not an element is present in a set.&Construct a set with a single element.ž"The number of elements in the set.Ÿ2Strict monoidal fold over the elements in the set. ”•–—˜™š›œžŸ ”œžš›•–—˜™ŸNone DFQTVåÌ 23456 789 None DFQTVæ~ ¡¢£¤ ¡¢£¤ NoneDFQTV÷ ¥A set of elements.¦The difference of two sets.§Infix operator for ¦.¨3Test whether or not an element is present in a set.©&Construct a set with a single element.ªCConvert a set to a list. The elements are given in ascending order.«Convert a list to a set.¬"The number of elements in the set.­IRight fold over the elements in the set. This is lazy in the accumulator.®.Strict left fold over the elements in the set.¯/Strict right fold over the elements in the set.°2Strict monoidal fold over the elements in the set.²'The functions that convert a list to a ¥' are asymptotically better that using : ©, with a cost of  O(n*log n) rather than O(n^2)j. If the input list is sorted, even if duplicate elements are present, the algorithm further improves to O(n)+. The fastest option available is calling  fromListNI on a presorted list and passing the correct size size of the resulting ¥r. However, even if an incorrect size is given to this function, it will still correctly convert the list into a ¥. ¥¦§¨©ª«¬­®¯° ¥©¨¬¦§ª«­®¯°¥; NoneDFQTV¬¸A set of elements.¹Test for membership in the set.º&Construct a set with a single element.»"The number of elements in the set.½'The functions that convert a list to a ¸' are asymptotically better that using : º, with a cost of  O(n*log n) rather than O(n^2)j. If the input list is sorted, even if duplicate elements are present, the algorithm further improves to O(n)+. The fastest option available is calling  fromListNI on a presorted list and passing the correct size size of the resulting ¸r. However, even if an incorrect size is given to this function, it will still correctly convert the list into a ¸.¸¹º»¸º¹»¸<= !" !"#$%&'()*+,-./#$0%&'()*+,-./#$/+,.123456789:";! 12345678<";! =123456789:<";!        1 "  ; !  #0&>? % @ $  1 A   0  # % @ $  0  1 & > ? A / * - . + , B # $  1 / * - . + , BCD2EFG0HIJ)'K(L#DEF$MNOPG%10&H####DEG$HQR#3STU<DEV2H0FG1456789:SWXYZ[ ##GDEV%H0$F1&>?A\#]0D^_`Sab # #c1primitive-containers-0.2.0-1GHiX4DqJpE54FSzUkSP2kData.Diet.Map.Lifted.LiftedData.Diet.Map.Unboxed.LiftedData.Diet.Set.LiftedData.Diet.Set.UnboxedData.Diet.Unbounded.Set.LiftedData.Map.Lifted.LiftedData.Map.Unboxed.LiftedData.Map.Unboxed.UnboxedData.Map.Unboxed.UnliftedData.Set.LiftedData.Map.Subset.LiftedData.Set.UnboxedData.Set.UnliftedData.ConcatenationData.Diet.Map.Internal Data.Diet.SetData.Diet.Set.Internal Data.Diet.Unbounded.Set.InternalData.Map.InternalData.Set.InternalData.Set.Lifted.InternalData.Map.Subset.InternalMap singletonlookupfromList fromListNfromListAppendfromListAppendN $fIsListMap $fMonoidMap$fSemigroupMap$fEqMap $fShowMapSetmember differencefoldraboveInclusivebelowInclusivebetweenInclusive $fIsListSet $fMonoidSet$fSemigroupSet$fOrdSet$fEqSet $fShowSettoListsizemapmapMaybefoldlWithKeyM'foldrWithKeyM'foldlMapWithKeyM'foldrMapWithKeyM'foldMapWithKey' foldlWithKey' foldrWithKey'$fOrdMapunsafeFreezeZip $fFunctorMapfoldl'foldr'\\foldMap'$fPrimUnliftedSet concatSizedemptyequalsconcatappend showsPrecliftShowsPrec2uncheckedSingletonaboveExclusivebelowExclusive indexLower indexUpperslicelocateSetSomeSetAllbaseGHC.BaseNothingcompareData.Semigroup Semigroup(primitive-0.6.4.0-AV4BEL9agJE6xAzoctYrcZData.Primitive.TypesPrimfoldlM'getSet MapElementMapValueMapEmpty Data.FoldablefoldMap