úÎ!µ£•ñÿ¨      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ € ‚ ƒ „ … † ‡ ˆ ‰ Š ‹ Œ Ž ‘ ’ “ ” • – — ˜ ™ š › œ ž Ÿ   ¡ ¢ £ ¤ ¥ ¦ § ¨ © ª « ¬ ­ ® ¯ ° ± ² ³ ´ µ ¶ · ¸ ¹ º » ¼ ½ ¾ ¿ À Á Â Ã Ä Å Æ Ç È É Ê Ë Ì Í Î Ï Ð Ñ Ò Ó Ô Õ Ö × Ø Ù ÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö÷øùúûüýþÿ      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—˜™š›œžŸ ¡¢£¤¥¦§%SafeVæ¨None DFQTV_©primitive-containers lower bound, Nothing means -"primitive-containers upper bound, Nothing means +"ªprimitive-containers!upper bound for negative infinityprimitive-containers!lower bound for positive infinite«¬­®¯°±©²³´NoneFQTV!fprimitive-containers”A diet set. Currently, the data constructor for this type is exported. Please do not use it. It will be moved to an internal module at some point.primitive-containersO(1)9 Create a continuous interval set with a single interval.primitive-containersO(log n) Returns True< if the element is a member of the continuous interval set.primitive-containers lower boundprimitive-containers upper bound   None+,-;<=>?CDFQTV"”Safe#None DFQTV*Ÿµprimitive-containerslower inclusive boundprimitive-containersupper inclusive bound¶primitive-containerslower inclusive boundprimitive-containersupper inclusive bound·primitive-containersinclusive lower boundprimitive-containersinclusive upper bound¸primitive-containersinclusive lower bound¹primitive-containersexclusive lower boundºprimitive-containersinclusive upper bound»primitive-containersexclusive upper bound¼½¾¿ÀÁµÃÄÅÆÇ·¸¹º»ÈÉÊËÌÍÎÏNone DFQTV+ŽÐÑÒÓÔÕÖ×ØÙÚÛÜÝÞßNoneFQTV3primitive-containersO(1)) Create a diet map with a single element.primitive-containersO(log n)& Lookup the value at a key in the map.primitive-containersinclusive lower boundprimitive-containersinclusive upper boundprimitive-containersvalue primitive-containersexpected size of resulting primitive-containerskey-value pairs"primitive-containersexpected size of resulting primitive-containerskey-value pairs !"! "NoneFQTVM› (primitive-containers”A diet set. Currently, the data constructor for this type is exported. Please do not use it. It will be moved to an internal module at some point.*primitive-containersO(1)) Create a diet set with a single element.+primitive-containersO(log n) Returns True, if the element is a member of the diet set..primitive-containersO(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./primitive-containers"The intersection of two diet sets.0primitive-containers—The negation of a diet set. The resulting set contains all elements that were not contained by the argument set, and it only contains these elements.2primitive-containersO(n)N The subset where all elements are greater than or equal to the given value. 3primitive-containersO(n)K The subset where all elements are less than or equal to the given value. 4primitive-containersO(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.*primitive-containersinclusive lower boundprimitive-containersinclusive upper bound-primitive-containers expected size of resulting diet (primitive-containerskey-value pairs.primitive-containersminuendprimitive-containers subtrahend/primitive-containersminuendprimitive-containers subtrahend2primitive-containersinclusive lower bound3primitive-containersinclusive upper bound4primitive-containersinclusive lower boundprimitive-containersinclusive upper bound ()*+,-./01234 ()*+./02341,-NoneFQTVg ;primitive-containers]A diet set. Currently, the data constructor for this type is exported. Please do not use it.=primitive-containersO(1)) Create a diet set with a single element.>primitive-containersO(log n)& Lookup the value at a key in the map.Bprimitive-containersO(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.Cprimitive-containers"The intersection of two diet sets.Dprimitive-containers—The negation of a diet set. The resulting set contains all elements that were not contained by the argument set, and it only contains these elements.Fprimitive-containersO(n)N The subset where all elements are greater than or equal to the given value. Gprimitive-containersO(n)K The subset where all elements are less than or equal to the given value. Hprimitive-containersO(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.=primitive-containersinclusive lower boundprimitive-containersinclusive upper boundAprimitive-containers expected size of resulting diet ;primitive-containerskey-value pairsBprimitive-containersminuendprimitive-containers subtrahendCprimitive-containersminuendprimitive-containers subtrahendFprimitive-containersinclusive lower boundGprimitive-containersinclusive upper boundHprimitive-containersinclusive lower boundprimitive-containersinclusive upper bound;<=>?@ABCDEFGH;<=>BCDFGHE?@ANoneFQTVv5Pprimitive-containersThe empty diet map.Qprimitive-containersO(1)) Create a diet map with a single element.Rprimitive-containersO(log n)& Lookup the value at a key in the map.Wprimitive-containersNMap an equality morphism over the values in a diet map. An equality morphism f must satisfy the law: " x y. x == y !” f x == f y%Since this does not actually use the à= constraint on the new value type, it is lazy in the values.Xprimitive-containerspConvert a diet set to a diet map, constructing each value from the low and high key in its corresponding range.Qprimitive-containersinclusive lower boundprimitive-containersinclusive upper boundprimitive-containersvalueTprimitive-containersexpected size of resulting Oprimitive-containerskey-value pairsVprimitive-containersexpected size of resulting Oprimitive-containerskey-value pairsWprimitive-containersequality morphism OPQRSTUVWX OPQRWXSUTVNoneFQTVy áprimitive-containerslower inclusive bound, Nothing means -"primitive-containersupper inclusive bound, Nothing means +"âãäáåæçNoneFQTV~K_primitive-containersO(1)4 Create an unbounded diet set with a single element.`primitive-containersO(log n) Returns True, if the element is a member of the diet set._primitive-containerslower inclusive bound, Nothing means -"primitive-containersupper inclusive bound, Nothing means +"^_`^_`None DFQTVPèprimitive-containersLMonoidal fold over the elements in the set. This is lazy in the accumulator.éprimitive-containerssaltprimitive-containerssetêëìíîïðñòóôõö÷øùúûüèýþÿé None DFQTVÁprimitive-containersO(n)/ Drop elements for which the predicate returns .primitive-containersO(n)/ Drop elements for which the predicate returns .primitive-containersO(n)/ Drop elements for which the predicate returns .primitive-containersÿgSort 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. This function is only unsafe because of the requirement that the arguments not be reused. If the arrays do not match in size, the larger one will be truncated to the length of the shorter one.primitive-containersThere are two preconditions:The array of keys is sorted?The array of keys and the array of values have the same length.hIf either of these conditions is not met, this function will introduce undefined behavior or segfaults.)      !"#$%&'()*+,NoneFQTVÐÜeprimitive-containersA map from keys k to values v4. The key type and the value type must both have - instances.fprimitive-containersThe empty diet map.gprimitive-containersO(log n)& Lookup the value at a key in the map.hprimitive-containersO(1)$ Create a map with a single element.iprimitive-containers 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.jprimitive-containers O(n*log n)( This function has the same behavior as iÎ 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 eS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.kprimitive-containers O(n*log n)( This function has the same behavior as i#, but it combines values with the .4 instances instead of choosing the last occurrence.lprimitive-containers O(n*log n)( This function has the same behavior as j#, but it combines values with the .4 instances instead of choosing the last occurrence.mprimitive-containersO(1)# The number of elements in the map.nprimitive-containersO(n) Map over the values in the map.oprimitive-containersO(n)/ Drop elements for which the predicate returns .pprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.qprimitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.rprimitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.sprimitive-containersO(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.tprimitive-containersO(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.uprimitive-containersO(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.vprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.wprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.xprimitive-containers 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. jprimitive-containersexpected size of resulting eprimitive-containerskey-value pairslprimitive-containersexpected size of resulting eprimitive-containerskey-value pairsqprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmaprprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapsprimitive-containers reductionprimitive-containersmaptprimitive-containers reductionprimitive-containersmapuprimitive-containers reduction primitive-containersmapvprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapwprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapefghijklmnopqrstuvwxefhgmnopvwuqrstikjlx NoneFQTVgprimitive-containersA map from keys k to values v4. The key type and the value type must both have - instances.€primitive-containersO(log n)& Lookup the value at a key in the map.primitive-containersThe empty diet map.‚primitive-containersO(1)$ Create a map with a single element.ƒprimitive-containersO(n). A list of key-value pairs in ascending order.„primitive-containers 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.…primitive-containers 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.†primitive-containers 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.‡primitive-containers 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.ˆprimitive-containersO(1)# The number of elements in the map.‰primitive-containersO(n) Map over the values in the map.Šprimitive-containersO(n)/ Drop elements for which the predicate returns .‹primitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.Œprimitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.primitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.Žprimitive-containersO(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.primitive-containersO(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.primitive-containersO(n)< Traverse the keys and values of the map from left to right.‘primitive-containersO(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.’primitive-containersO(n)> Left fold over the keys and values with a strict accumulator.“primitive-containersO(n)? Right fold over the keys and values with a strict accumulator.”primitive-containers 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. …primitive-containersexpected size of resulting primitive-containerskey-value pairs‡primitive-containersexpected size of resulting primitive-containerskey-value pairsŒprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapŽprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmap‘primitive-containers reduction primitive-containersmap’primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap“primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap€‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”‚€ˆ‰Š‹’“‘ŒŽƒ„†…‡” None ,<CFQTVG§primitive-containersRThis function is really unsafe. The user needs to use unsafeCoerce to even use it.›œžŸ ¡¢£¤¥¦§¨©ª«¬­®¯°±²³´›œžŸ¢¥¦±´²³¤£¬­®¯§ ¡¨«©ª° None<Uµ¶·µ¶· None,FKQTV㸹º»¼½¾¸¹º¼»½¾!NoneDFQTV WÈprimitive-containersCConvert a set to a list. The elements are given in ascending order.Éprimitive-containersConvert a list to a set.Êprimitive-containersIRight fold over the elements in the set. This is lazy in the accumulator.Ëprimitive-containers.Strict left fold over the elements in the set.Ìprimitive-containers/Strict right fold over the elements in the set.Ç/0ÈÉÊËÌ NoneDFQTV-Ù Íprimitive-containersThe difference of two sets.Îprimitive-containersThe intersection of two sets.Ïprimitive-containersThe empty set.Ðprimitive-containersInfix operator for Í.Ñprimitive-containersTrue if the set is emptyÒprimitive-containers3Test whether or not an element is present in a set.Óprimitive-containers&Construct a set with a single element.Ôprimitive-containers"The number of elements in the set.Õprimitive-containers2Strict monoidal fold over the elements in the set.Öprimitive-containers0Lazy monoidal fold over the elements in the set.×primitive-containersO(1)c Convert a set to an array. The elements are given in ascending order. This function is zero-cost.Øprimitive-containers&Traverse a set, discarding the result.Ùprimitive-containers7Traverse a set with the indices, discarding the result.ÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ×ØÙÇÏÓÑÒÔÍÐÎ×ÈÉÊËÌÕÖØÙ"None DFQTV.÷Ú12345None DFQTV/–ÚÛÜÝÞÚÛÜÝÞ#None 3DFQTV0Lß67à89:;NoneFQTVmÙáprimitive-containersA map from keys k to values v4. The key type and the value type must both have Prim instances.ãprimitive-containersThe empty diet map.äprimitive-containersO(log n)& Lookup the value at a key in the map.åprimitive-containersO(1)$ Create a map with a single element.æprimitive-containers 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.çprimitive-containers 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.èprimitive-containers 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.éprimitive-containersO(n)µ Build a map from a set. This function is uses the underlying array that backs the set as the array for the keys. It constructs the values by apply the given function to each key.êprimitive-containers 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.ëprimitive-containersO(1)# The number of elements in the map.ìprimitive-containersO(n) Map over the values in the map.íprimitive-containersO(n)/ Drop elements for which the predicate returns .îprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.ïprimitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.ðprimitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.ñprimitive-containersO(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.òprimitive-containersO(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.óprimitive-containersO(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.ôprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.õprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.öprimitive-containersO(n+m) The expression (ö t1 t2") takes the left-biased union of t1 and t2 . It prefers t1% when duplicate keys are encountered.÷primitive-containersO(1)4 The values in a map. This is a zero-cost operation. çprimitive-containersexpected size of resulting áprimitive-containerskey-value pairsêprimitive-containersexpected size of resulting áprimitive-containerskey-value pairsïprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapðprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapñprimitive-containers reductionprimitive-containersmapòprimitive-containers reductionprimitive-containersmapóprimitive-containers reduction primitive-containersmapôprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapõprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapáâãäåæçèéêëìíîïðñòóôõö÷áâãåäëìíîöôõóïðñòæèçêé÷None DFQTVwlÿprimitive-containers*A subset map with a single set as its key.primitive-containersžA subset map with a single negative set as its key. That is, a lookup into this map will only succeed if the needle set and the negative set do not overlap.primitive-containers4Construct a singleton subset map by interpreting a Data.Map.Unlifted.Lifted.Map8 as requirements about what must be present and absent.primitive-containers negative setprimitive-containersvalueprimitive-containers&Map of required presences and absencesßàÿßàÿ$NoneDFQTVƒprimitive-containersA set of elements.primitive-containersCConvert a set to a list. The elements are given in ascending order.primitive-containersConvert a list to a set.<primitive-containers'The functions that convert a list to a ' are asymptotically better that using =  singleton, 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’4primitive-containersThe empty set. primitive-containersThe difference of two sets. primitive-containersInfix operator for  . primitive-containersThe intersection of two sets. primitive-containers3Test whether or not an element is present in a set. primitive-containersO(1) Is the set empty?primitive-containers&Construct a set with a single element.primitive-containers"The number of elements in the set.primitive-containersIRight fold over the elements in the set. This is lazy in the accumulator.primitive-containers.Strict left fold over the elements in the set.primitive-containers/Strict right fold over the elements in the set.primitive-containers2Strict monoidal fold over the elements in the set.primitive-containers0Lazy monoidal fold over the elements in the set.primitive-containers&Traverse a set, discarding the result.primitive-containers7Traverse a set with the indices, discarding the result.          NoneFQTVÙáprimitive-containersA map from keys k to values v. The key type must have a -. instance and the value type is unconstrained.primitive-containersO(log n)& Lookup the value at a key in the map.primitive-containersThe empty map.primitive-containersO(1)$ Create a map with a single element.primitive-containersO(n). A list of key-value pairs in ascending order.primitive-containers 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.primitive-containers 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.primitive-containers 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.primitive-containers 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. primitive-containersO(1)# The number of elements in the map.!primitive-containersO(n) Map over the values in the map."primitive-containersO(n)/ Drop elements for which the predicate returns .#primitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.$primitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.%primitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.&primitive-containersO(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.'primitive-containersO(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.(primitive-containersO(n)> Left fold over the keys and values with a strict accumulator.)primitive-containersO(n)= Right fold over the keys and values with a lazy accumulator.*primitive-containersO(n)? Right fold over the keys and values with a strict accumulator.+primitive-containersO(n)÷ Fold over the keys and values of the map with a lazy 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.,primitive-containersO(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.-primitive-containers 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. .primitive-containersO(1) Get the keys from the map.1primitive-containersO(1)4 The values in a map. This is a zero-cost operation.9primitive-containers1This fails the functor laws since fmap is strict.primitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairs'primitive-containers reductionprimitive-containersmap(primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap)primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap*primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap !"#$%&'()*+,-./01 !"#./0)(*+,$%&'1-None ,<FKQTVâJprimitive-containers+This function is even more unsafe than the unsafeFreezeZip provided by Data.Map.Unboxed.Lifted. The user needs to use  unsafeCoerce to even use this function.Kprimitive-containersO(1)L This function is highly unsafe. The user is responsible for ensuring that:Both k' and  forall a. k a& have the same runtime representation.The Ord instance for k' agrees with the  OrdForallPoly instance for k.:;<=>?@ABCDEFGHIJK:;<=>BCDE@?FIGHAJK%NoneDFQTVí³Uprimitive-containersO(n)D Convert a set to a list. The elements are given in ascending order.Vprimitive-containers O(n*log n) Convert a list to a set.?primitive-containers'The functions that convert a list to a T' are asymptotically better that using =  singleton, 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 Tr. However, even if an incorrect size is given to this function, it will still correctly convert the list into a T.T@AUVNoneDFQTVþ<Wprimitive-containersTest for membership in the set.Xprimitive-containersThe empty set.Yprimitive-containersTrue if the set is emptyZprimitive-containers&Construct a set with a single element.[primitive-containers"The number of elements in the set.\primitive-containersThe difference of two sets.]primitive-containersThe intersection of two sets.^primitive-containersO(1)c Convert a set to an array. The elements are given in ascending order. This function is zero-cost._primitive-containersIRight fold over the elements in the set. This is lazy in the accumulator.`primitive-containersLMonoidal fold over the elements in the set. This is lazy in the accumulator.aprimitive-containers.Strict left fold over the elements in the set.bprimitive-containers/Strict right fold over the elements in the set.cprimitive-containers2Strict monoidal fold over the elements in the set.dprimitive-containers&Traverse a set, discarding the result.eprimitive-containers7Traverse a set with the indices, discarding the result.TUVWXYZ[\]^_`abcdeTXZYW[\]^UV_`abcdeNoneFQTVBáfprimitive-containersA map from keys k to values v. The key type must have a B) instance and the value type must have a - instance.gprimitive-containersO(log n)& Lookup the value at a key in the map.hprimitive-containersThe empty diet map.iprimitive-containersO(1)$ Create a map with a single element.jprimitive-containers 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.kprimitive-containers O(n*log n)( This function has the same behavior as jÎ 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 fS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.lprimitive-containers O(n*log n)( This function has the same behavior as j#, but it combines values with the .4 instances instead of choosing the last occurrence.mprimitive-containers O(n*log n)( This function has the same behavior as k#, but it combines values with the .4 instances instead of choosing the last occurrence.nprimitive-containersO(n)µ Build a map from a set. This function is uses the underlying array that backs the set as the array for the keys. It constructs the values by apply the given function to each key.oprimitive-containersO(1)# The number of elements in the map.pprimitive-containersO(n) Map over the values in the map.qprimitive-containersO(n)/ Drop elements for which the predicate returns .rprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.sprimitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.tprimitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.uprimitive-containersO(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.vprimitive-containersO(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.wprimitive-containersO(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.xprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.yprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.zprimitive-containers 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. kprimitive-containersexpected size of resulting fprimitive-containerskey-value pairsmprimitive-containersexpected size of resulting fprimitive-containerskey-value pairssprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmaptprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapuprimitive-containers reductionprimitive-containersmapvprimitive-containers reductionprimitive-containersmapwprimitive-containers reduction primitive-containersmapxprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapyprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapfghijklmnopqrstuvwxyzfhigopqrxywstuvjlkmnzNoneFQTV‹lprimitive-containersA map from keys k to values v. The key type must have a B) instance and the value type must have a Prim instance.SThe data constructor for this type should not be exported. I am working on this.ƒprimitive-containersO(log n)& Lookup the value at a key in the map.„primitive-containersThe empty diet map.…primitive-containersO(1)$ Create a map with a single element.†primitive-containers 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.‡primitive-containers 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.ˆprimitive-containers 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.‰primitive-containersO(n)µ Build a map from a set. This function is uses the underlying array that backs the set as the array for the keys. It constructs the values by apply the given function to each key.Šprimitive-containers 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.‹primitive-containersO(1)# The number of elements in the map.Œprimitive-containersO(n) Map over the values in the map.primitive-containersO(n)/ Drop elements for which the predicate returns .Žprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.primitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.primitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.‘primitive-containersO(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.’primitive-containersO(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.“primitive-containersO(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.”primitive-containersO(n)> Left fold over the keys and values with a strict accumulator.•primitive-containersO(n)? Right fold over the keys and values with a strict accumulator.–primitive-containers 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. —primitive-containersO(n+m) The expression (— t1 t2") takes the left-biased union of t1 and t2 . It prefers t1% when duplicate keys are encountered. ‡primitive-containersexpected size of resulting primitive-containerskey-value pairsŠprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap‘primitive-containers reductionprimitive-containersmap’primitive-containers reductionprimitive-containersmap“primitive-containers reduction primitive-containersmap”primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap•primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap‚ƒ„…†‡ˆ‰Š‹ŒŽ‘’“”•–—‚„…ƒ‹ŒŽ—”•“‘’†ˆ‡Š‰–None DFQTVŒªÚžŸ ¡ÚžŸ ¡None DFQTV•­¢primitive-containers*A subset map with a single set as its key.£primitive-containersžA subset map with a single negative set as its key. That is, a lookup into this map will only succeed if the needle set and the negative set do not overlap.¤primitive-containers4Construct a singleton subset map by interpreting a Data.Map.Unlifted.Lifted.Map8 as requirements about what must be present and absent.£primitive-containers negative setprimitive-containersvalue¤primitive-containers&Map of required presences and absencesßࢣ¤¥¦§ßࢣ¤¥¦§C&'()*+,-./01234567899:;<=>?@A*BCDEFGHIJK))*+CDLMNOPQRS01T23))*+UCDLMNOPQRS01T23A,*BCDEFVWGHIJK)*+3012A,B*CDEFXYZ[\]^_`abcKGdJHI A B , * U C D E F X Y Z [ \ ] ^ _ e ` a b c K G d J H I A A , . * f g B h i C D c j k e \ U l m n X Y Z [ o A * B A * B C U Z [ p q H I d J K G!)!U!C!O!r!s L M , t . + * X u v w x y"A*BUC#A#,AA,B*CDEWFXYZ[\]^_`abz{KGdJHI|*}~BUC$)$U$C,LtM+.*XOrsuvxyAB,*UCDEFXYZ[\]^_ajbk`c€{KGdJHI‚|A,.*BCUXj\keYZ[ocƒHIpqdJKG%)%U%C+,.*XLMwOvrsuxyAB,*CDEFWXYZ[\]^_`abcKGdJHIAAB,*CDEWFXYZ[\]^_`abczKGdJHI*BUC*}~BUC„*…))m,-./h+l*†RP‡Qˆ)),mDC‰+Š‹ŒhNLMXUOlA,YmDCFE‰*BhUWlŽ‘*),mh+lv’))h.,mnDCLMlUw+‰*XOrsu“xy o”•– Z [ c — A , . * m n D C F E Y l U j k ‰ i ˜ ™ h € B X \ ] ^ e _ ` a b W  { š›œ”•ž!)!Ÿ"U"C","*"B#U#C#*#}#~#B$S” v$)%S%)%Ÿ›¡¢£1primitive-containers-0.3.0-6S9XYO496hfD8FzKOOq43EData.Continuous.Set.LiftedData.Dependent.Map.Class"Data.Diet.Map.Strict.Lifted.LiftedData.Diet.Set.LiftedData.Diet.Set.Unboxed#Data.Diet.Map.Strict.Unboxed.LiftedData.Diet.Unbounded.Set.LiftedData.Map.Unboxed.UnliftedData.Map.Unboxed.UnboxedData.Dependent.Map.Internal"Data.Dependent.Map.Unlifted.Lifted Data.Dependent.Map.Lifted.LiftedData.Set.LiftedData.Map.Subset.Strict.LiftedData.Map.Subset.Lazy.LiftedData.Map.Lifted.LiftedData.Set.UnboxedData.Map.Unboxed.Lifted!Data.Dependent.Map.Unboxed.LiftedData.Set.UnliftedData.Map.Unlifted.UnboxedData.Map.Unlifted.LiftedData.Map.Subset.Strict.UnliftedData.Map.Subset.Lazy.UnliftedData.ConcatenationData.Continuous.Set.Internal Data.Diet.SetData.Diet.Set.InternalData.Diet.Map.Strict.Internal Data.Diet.Unbounded.Set.InternalData.Set.InternalData.Map.InternalData.Set.Lifted.InternalData.Map.Subset.Strict.InternalData.Map.Subset.Lazy.InternalData.Set.Unboxed.InternalData.Set.Unlifted.Internal Inclusivity Exclusive InclusiveSet singletonmemberemptyuniversenull universal $fMonoidSet$fSemigroupSet$fEqSet $fShowSet Universally universallyApplyUniversallyapplyUniversallyLiftedapplyUniversallyUnliftedApply $fPrimApply $fOrdApply $fEqApply$fApplyUniversallykfAlways$fPrimUnliftedApply$fUniversallykfPrimUnlifted$fUniversallykfAlwaysMaplookupfromList fromListNfromListAppendfromListAppendN $fIsListMap $fMonoidMap$fSemigroupMap$fEqMap $fShowMap difference intersectionnegatefoldraboveInclusivebelowInclusivebetweenInclusive $fIsListSet$fOrdSettoListmapEqualityMorphismfromSetsizemapmapMaybemapMaybeWithKeyfoldlWithKeyM'foldrWithKeyM'foldlMapWithKeyM'foldrMapWithKeyM'foldMapWithKey' foldlWithKey' foldrWithKey'unsafeFreezeZip$fOrdMaptraverseWithKey_toJSON parseJSONappendappendRightBiased foldrWithKeyfoldMapWithKey showsPrecequalscompare mapWithKey $fFromJSONMap $fToJSONMapfoldl'foldr'\\foldMap'foldMaptoArray traverse_ itraverse_unionelems $fFunctorMap antisingletonfromPolaritieskeysintersectionWithrestrict $fNFDataMapunsafeCoerceKeys concatSized infinitiesuncheckedSingletonaboveExclusivebelowExclusiveconcat indexLower indexUpperslicelocateliftShowsPrec2ghc-prim GHC.ClassesEqliftHashWithSaltfoldlM'baseGHC.BaseNothingunsafeZipPresorted appendKeyWith appendWithrnf(primitive-0.6.4.0-39Pwmm1zkQX6bM7xFUT3JcData.Primitive.TypesPrim SemigroupgetSet Data.FoldableData.Primitive.UnliftedArray PrimUnlifted