!}mU      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|} ~        !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~     *SafeX!Jprimitive-containersConcatenate all the values in the list in the order they are given. This function attempts to perform smaller concatenations together. This is good for data structures that do not take advantage of sharing.primitive-containers|This function is likely to be used for things like intersection where the zero-sized element is not an identity but a zero.None FHSVXa%iprimitive-containers lower bound, Nothing means -"primitive-containers upper bound, Nothing means +"primitive-containers!upper bound for negative infinityprimitive-containers!lower bound for positive infinite !NoneHSVX,primitive-containersA 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,-.=>?@AEFHSVX-Safe.jNone FHSVX6"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)*+,-./"01234$%&'(56789:;< None FHSVX6=>?@ABCDEFGHIJKLNoneHSVX>primitive-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 !"! "NoneHSVXY (primitive-containersA 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-containersThe 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,-NoneHSVXr ;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-containersThe 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?@ANoneHSVX]Pprimitive-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-containersFMap an equality morphism over the values in a diet map. An bijection f must satisfy the law: " x y. x == y ! f x == f y%Since this does not actually use the M= 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-containers bijection OPQRSTUVWX OPQRWXSUTV!NoneHSVX2Nprimitive-containerslower inclusive bound, Nothing means -"primitive-containersupper inclusive bound, Nothing means +"OPQNRSTNoneHSVXs_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 +"^_`^_`"Safe#NoneFSX Uprimitive-containers The key array is the same length as the value array. Every key is the upper bound of a range. The keys array always has a length of at least one. The last element is always maxBound. The lowest bound is assumed to be minBound. For example, the interval map of Int16: ![-inf,5],[6,17],[18,20],[21,+inf]!Would be represented by the keys:  5,17,20,65536UVWXYZ[\]^_`abcdefghijklNone FHSVXeprimitive-containersA total interval map from keys k to values vQ. The key type must be discrete and bounded. This map is strict in the values.iprimitive-containersCreate an interval map from a list of range-value triples. The first argument is a default value used everywhere outside of the given ranges. In the case of overlapping ranges, the leftmost value is used.jprimitive-containersQThis only provides a correct result when the effectful mapping is a bijection.kprimitive-containersQThis only provides a correct result when the effectful mapping is a bijection.uprimitive-containersaThe number of values in the interval map. Also the number of contiguous key ranges in the map.gprimitive-containersvalue outside of the intervalprimitive-containers lower boundprimitive-containers upper boundprimitive-containersvalue inside the intervaliprimitive-containersvalue outside of the rangesprimitive-containers9low-high inclusive ranges with their corresponding valuesefghijklmnopqrstuvwefghirnmjkopqstluvw$None FHSVXvmprimitive-containersLMonoidal fold over the elements in the set. This is lazy in the accumulator.nprimitive-containerssaltprimitive-containersset!opqrstuvwxyz{|}~mn%None FHSVX_qprimitive-containersO(n)? Map over the elements with access to their corresponding keys.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-containersgSort 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.0 None -.>EHSVXrprimitive-containersRThis function is really unsafe. The user needs to use unsafeCoerce to even use it.}~}~ None> None-HMSVX&NoneFHSVXprimitive-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. NoneFHSVXTprimitive-containersThe difference of two sets.primitive-containersThe intersection of two sets.primitive-containers1Do the two sets contain any of the same elements?primitive-containers6Is the first argument a subset of the second argument?primitive-containersThe empty set.primitive-containersInfix operator for .primitive-containersTrue if the set is emptyprimitive-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 FHSVXЂ None FHSVX!(None 4FHSVXNoneHSVX{primitive-containersA map from keys k to values v.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-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-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 pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapNoneHSVXOprimitive-containersA map from keys k to values v.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-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-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-containersO(1)4 The values in a map. This is a zero-cost operation. primitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapNone FHSVXXprimitive-containers*A subset map with a single set as its key.primitive-containersA 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    )NoneFHSVXd] 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  .   NoneFHSVX}primitive-containersThe empty set.primitive-containersThe difference of two sets.primitive-containersInfix operator for .primitive-containersThe intersection of two sets.primitive-containers1Do the two sets contain any of the same elements?primitive-containers6Is the first argument a subset of the second argument?primitive-containersLThe set that includes all elements from the lower bound to the upper bound.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"Construct a set with two elements.primitive-containers"Construct a set with two elements.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-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.#primitive-containersIMap over the elements of a set. The provided function must be monotonic.primitive-containersInclusive lower boundprimitive-containersInclusive upper bound    !"#    !"#NoneHSVXS$primitive-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(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-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. The function can perform primitive monadic effects./primitive-containersO(1)# The number of elements in the map.0primitive-containersO(n) Map over the values in the map.1primitive-containersO(n)/ Drop elements for which the predicate returns .2primitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.3primitive-containersvUpdate the values at any number of keys. This is done on in a buffer without building intermediate maps. Example use: dadjustMany (\adjust -> do adjust 2 (\x -> pure (x + 1)) adjust 3 (\_ -> pure 42) ) myMapqThis increments by 1 the value associated with key 2. Then, it replaces with 42 the value associated with key 3.4primitive-containersThis has the same behavior as 3r. However, it will be inlined rather than specialized. The can prevent needless boxing in the callback. Use  -ddump-simplX and standard profiling techniques to figure out if this function actually helps you.5primitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.6primitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.7primitive-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.8primitive-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.9primitive-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 pairs3primitive-containersModification-applying functionprimitive-containersMap4primitive-containersModification-applying functionprimitive-containersMap5primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap6primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap7primitive-containers reductionprimitive-containersmap8primitive-containers reductionprimitive-containersmap9primitive-containers reductionprimitive-containersmap:primitive-containers reduction primitive-containersmap;primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap<primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap$%&'()*+,-./0123456789:;<=$&'%/01234;<:56789()+*,-.=NoneHSVX&JDprimitive-containersA map from keys k to values v. The key type must have a . instance and the value type is unconstrained.Fprimitive-containersO(log n)& Lookup the value at a key in the map.Gprimitive-containersThe empty map.Hprimitive-containersO(1)$ Create a map with a single element.Iprimitive-containersO(n). A list of key-value pairs in ascending order.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 DS. 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 applying 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)? Map over the elements with access to their corresponding keys.Uprimitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.Vprimitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.Wprimitive-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.Xprimitive-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.Yprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.Zprimitive-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.aprimitive-containersTake the intersection of all of the maps, combining elements at equal keys with the provided function. Since intersection of maps lacks an identity, this is provided with a non-empty list.cprimitive-containersO(1)4 The values in a map. This is a zero-cost operation.kprimitive-containers1This fails the functor laws since fmap is strict.Kprimitive-containersexpected size of resulting Dprimitive-containerskey-value pairsMprimitive-containersexpected size of resulting Dprimitive-containerskey-value pairsXprimitive-containers reductionprimitive-containersmapYprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapZprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap[primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap DEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abc DEGHFOPQRS_`abTZY[\]UVWXIJLKMNc^NoneHSVX~lprimitive-containersA map from keys k to values v4. The key type and the value type must both have  instances.mprimitive-containersThe empty diet map.nprimitive-containersO(log n)& Lookup the value at a key in the map.oprimitive-containersO(1)$ Create a map with a single element.pprimitive-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.qprimitive-containers O(n*log n)( This function has the same behavior as p 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 lS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.rprimitive-containers O(n*log n)( This function has the same behavior as p#, but it combines values with the 4 instances instead of choosing the last occurrence.sprimitive-containers 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.tprimitive-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.uprimitive-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. The function can perform primitive monadic effects.vprimitive-containersO(1)# The number of elements in the map.wprimitive-containersO(n) Map over the values in the map.xprimitive-containersO(n)M Map over the values in the map. The resulting map contains lifted values.yprimitive-containersO(n)/ Drop elements for which the predicate returns .zprimitive-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-containersvUpdate the values at any number of keys. This is done on in a buffer without building intermediate maps. Example use: dadjustMany (\adjust -> do adjust 2 (\x -> pure (x + 1)) adjust 3 (\_ -> pure 42) ) myMapqThis increments by 1 the value associated with key 2. Then, it replaces with 42 the value associated with key 3.}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 values of the map.primitive-containersO(n) Fold over the keys and values of the map with a 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-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. qprimitive-containersexpected size of resulting lprimitive-containerskey-value pairssprimitive-containersexpected size of resulting lprimitive-containerskey-value pairs|primitive-containersModification-applying functionprimitive-containersMap}primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap~primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmaplmnopqrstuvwxyz{|}~lmonvwxyz{|}~prqstuNone ->HMSVX primitive-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.primitive-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.*NoneFHSVXprimitive-containersO(n)D Convert a set to a list. The elements are given in ascending order.primitive-containers O(n*log n) Convert 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 .NoneFHSVX{primitive-containersTest for membership in the set.primitive-containersThe empty set.primitive-containersTrue if the set is emptyprimitive-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-containers1Do the two sets contain any of the same elements?primitive-containers6Is the first argument a subset of the second argument?primitive-containersLThe set that includes all elements from the lower bound to the upper bound.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.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-containers&Traverse a set, discarding the result.primitive-containers7Traverse a set with the indices, discarding the result.primitive-containersInclusive lower boundprimitive-containersInclusive upper boundNoneFHSVXprimitive-containersO(n)D Convert a set to a list. The elements are given in ascending order.primitive-containers O(n*log n) Convert a list to a set.primitive-containersO(1)0 Convert a set to a non-empty set. This returns Nothinga if the set is empty. The resulting non-empty set shares internal represention as the argument.primitive-containersO(0)k Convert a non-empty set to a set. The resulting set shares the internal representation with the argument.primitive-containersTest for membership in the set.primitive-containers&Construct a set with a single element.primitive-containers"The number of 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-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.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-containers&Traverse a set, discarding the result.primitive-containers7Traverse a set with the indices, discarding the result.NoneHSVXprimitive-containersA map from keys k to values v. The key type must have a ) instance and the value type must have a  instance.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-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-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-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapNoneHSVXK:primitive-containersA map from keys k to values v. The key type must have a ) 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-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 applying the given function to each key.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 pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapNone FHSVXLx        None FHSVXU{primitive-containers*A subset map with a single set as its key.primitive-containersA 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+,-./0123456789:;<=>>?@ABCDEF/GHIJKLMNOP../0HIQRSTUVWX56Y78../0ZHIQRSTUVWX56Y78F1/GHIJK[\LMNOP./08567F]/GH^_`[abcdefghiZLPMNO F F 1 3 / j k G l m H I n f o p g Z q r s h a t u v F / G F / G H Z t u w x M N y O P L&.&Z&H&T&b&z Q R { | 1 } 3 0 / h ~ d  ` 'F / G Z H(F(1FF1G/ZHIJ\KhatugiPLyOMNFF1G/ZHIJ\KhatugiPLyOMN/GZH).)Z)H1Q}R{|03/hTbz~d`FG1/ZHIJK\hatugpnPLyOMNFFG1/ZHIJK\hatuvgfoniPLyOMNF1G/HIJK\hatugonPLyOMNF13/GHZhfgopatuvnMNwxyOPL*.*Z*H013/hQR{|Tdbz~`.Z\0/hTdbz~`8Y76FG1/HIJK\hatugnPLyOMNFFG1/HIJK\hatugnPLyOMN/GZH/GZH/..r1234l0q/WUV..1rIH0lSQRhZTq F 1 a r I H K J / G l Z \ q !/!.!1!r!l!0!q#F#r#h#[#a###`#]#1#/#G##e#q#f#g#b#c#d#Z#H##i$d$$.$.$l$3$1$r$s$a$I$H$$Q${$R$q$Z$$0$$/$$$h$T$b$z$~$c$`$$|%v%t%%u%n%%F%1%3%/%r%s%I%H%K%J%a%q%Z%f%o%%%%%m%%%l%%G%h%%g%%%%p%%%%%%\%%%i%&.&'Z'H'1'/'G(Z(H(/(((G)Xd).*X*.*1primitive-containers-0.3.2-2wKb1T6Zx0qG1dqFRuoU2DData.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.Interval.DBTSLLData.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.UnliftedData.Map.Lifted.LiftedData.Set.UnboxedData.Map.Unboxed.UnboxedData.Map.Unboxed.LiftedData.Map.Unboxed.Unlifted!Data.Dependent.Map.Unboxed.LiftedData.Set.UnliftedData.Set.NonEmpty.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.Map.IntervalData.Map.Interval.DBTS.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$fOrdSettoList mapBijectionfromSetpuretraverseBijectionPtraverseBijection traverse_mapfoldl'foldlM'foldMap unionWith foldrWithKeyfoldlWithKeyM'sizeelemstoJSON parseJSONappendappendRightBiasedunsafeFreezeZipfoldMapWithKeytraverseWithKey_ showsPrecequalscomparemapMaybemapMaybeWithKey mapWithKey $fFromJSONMap $fToJSONMap$fOrdMapfoldr' intersectssubset\\foldMap'toArray itraverse_ appendWithKeyfoldrWithKeyM'foldlMapWithKeyM'foldrMapWithKeyM'foldMapWithKey' foldlWithKey' foldrWithKey'unionkeys $fFunctorMap antisingletonfromPolarities enumFromTo doubleton tripleton mapMonotonicfromSetP adjustManyadjustManyInlineintersectionWithintersectionsWithrestrict $fNFDataMap mapLifted mapMaybePtraverseunsafeCoerceKeys fromNonEmptytoSet $fHashableSet$fPrimUnliftedSet concatSized concatSized1 infinitiesuncheckedSingletonaboveExclusivebelowExclusiveconcat indexLower indexUpperslicelocateliftShowsPrec2ghc-prim GHC.ClassesEq traversePliftHashWithSaltbase GHC.MaybeNothingunsafeZipPresorted appendWithsizeKeysrnfgetSetGHC.Base Semigroup Data.Foldable(primitive-0.6.4.0-1mvPxVOk6Q6KOkWCZxqESfData.Primitive.TypesPrimData.Primitive.UnliftedArray PrimUnlifted