!      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~          !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~'SafeX primitive-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$ 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    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   Safe,None FHSVX4Hprimitive-containerslower inclusive boundprimitive-containersupper inclusive boundprimitive-containerslower inclusive boundprimitive-containersupper inclusive boundprimitive-containersinclusive lower boundprimitive-containersinclusive upper boundprimitive-containersinclusive lower boundprimitive-containersexclusive lower boundprimitive-containersinclusive upper boundprimitive-containersexclusive upper bound !"#$%&'()*+,-./None FHSVX570123456789:;<=>?NoneHSVX<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-containersvalueprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsNoneHSVXWD 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."primitive-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.$primitive-containersO(n)N The subset where all elements are greater than or equal to the given value. %primitive-containersO(n)K The subset where all elements are less than or equal to the given value. &primitive-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 boundprimitive-containers expected size of resulting diet primitive-containerskey-value pairs primitive-containersminuendprimitive-containers subtrahend!primitive-containersminuendprimitive-containers subtrahend$primitive-containersinclusive lower bound%primitive-containersinclusive upper bound&primitive-containersinclusive lower boundprimitive-containersinclusive upper bound  !"#$%&  !"$%&#NoneHSVXp -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.0primitive-containersO(log n)& Lookup the value at a key in the map.4primitive-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.5primitive-containers"The intersection of two diet sets.6primitive-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.8primitive-containersO(n)N The subset where all elements are greater than or equal to the given value. 9primitive-containersO(n)K The subset where all elements are less than or equal to the given value. :primitive-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 bound3primitive-containers expected size of resulting diet -primitive-containerskey-value pairs4primitive-containersminuendprimitive-containers subtrahend5primitive-containersminuendprimitive-containers subtrahend8primitive-containersinclusive lower bound9primitive-containersinclusive upper bound:primitive-containersinclusive lower boundprimitive-containersinclusive upper bound-./0123456789:-./045689:7123NoneHSVXBprimitive-containersThe empty diet map.Cprimitive-containersO(1)) Create a diet map with a single element.Dprimitive-containersO(log n)& Lookup the value at a key in the map.Iprimitive-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 @= constraint on the new value type, it is lazy in the values.Jprimitive-containerspConvert a diet set to a diet map, constructing each value from the low and high key in its corresponding range.Cprimitive-containersinclusive lower boundprimitive-containersinclusive upper boundprimitive-containersvalueFprimitive-containersexpected size of resulting Aprimitive-containerskey-value pairsHprimitive-containersexpected size of resulting Aprimitive-containerskey-value pairsIprimitive-containers bijection ABCDEFGHIJ ABCDIJEGFHNoneHSVXsAprimitive-containerslower inclusive bound, Nothing means -"primitive-containersupper inclusive bound, Nothing means +"BCDAEFGNoneHSVXQprimitive-containersO(1)4 Create an unbounded diet set with a single element.Rprimitive-containersO(log n) Returns True, if the element is a member of the diet set.Qprimitive-containerslower inclusive bound, Nothing means -"primitive-containersupper inclusive bound, Nothing means +"PQRPQRSafe None %'FHSXgHprimitive-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,65536HIJKLMNOPQRSTUVWXYZ[\]^_`aNone FHSVXRWprimitive-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.\primitive-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.]primitive-containersQThis only provides a correct result when the effectful mapping is a bijection.^primitive-containersQThis only provides a correct result when the effectful mapping is a bijection.hprimitive-containersaThe number of values in the interval map. Also the number of contiguous key ranges in the map.Zprimitive-containersvalue outside of the intervalprimitive-containers lower boundprimitive-containers upper boundprimitive-containersvalue inside the interval\primitive-containersvalue outside of the rangesprimitive-containers9low-high inclusive ranges with their corresponding valuesWXYZ[\]^_`abcdefghijWXYZ[\ea`]^bcdfg_hijNone FHSVXqprimitive-containersA total interval map from keys k to values vn. The key type must be discrete and bounded. This map is strict in the values. The key type must have a b instance.tprimitive-containersO(log n)_ Lookup a key. The value corresponding to the range that contains this key will be returned.uprimitive-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.vprimitive-containersQThis only provides a correct result when the effectful mapping is a bijection.wprimitive-containersQThis only provides a correct result when the effectful mapping is a bijection.primitive-containersaThe number of values in the interval map. Also the number of contiguous key ranges in the map.sprimitive-containersvalue outside of the intervalprimitive-containers lower boundprimitive-containers upper boundprimitive-containersvalue inside the intervaluprimitive-containersvalue outside of the rangesprimitive-containers9low-high inclusive ranges with their corresponding valuesqrstuvwxyz{|}~qrstu~zyvw{|}x None FHSVXprimitive-containersA total interval map from keys k to values v. The key type must be discrete and bounded. This map is strict in the values. The key type and the value type must both have b instances.primitive-containersO(log n)_ Lookup a key. The value corresponding to the range that contains this key will be returned.primitive-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.primitive-containersQThis only provides a correct result when the effectful mapping is a bijection.primitive-containersQThis only provides a correct result when the effectful mapping is a bijection.primitive-containersaThe number of values in the interval map. Also the number of contiguous key ranges in the map.primitive-containersvalue outside of the intervalprimitive-containers lower boundprimitive-containers upper boundprimitive-containersvalue inside the intervalprimitive-containersvalue outside of the rangesprimitive-containers9low-high inclusive ranges with their corresponding values!None FHSVXʑcprimitive-containersLMonoidal fold over the elements in the set. This is lazy in the accumulator.dprimitive-containerssaltprimitive-containersset"efghijklmnopqrstuvwxyz{|}c~d"None FHSVX_ڐprimitive-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.1#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. NoneFHSVX|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-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-containersO(log n) . Lookup the indexS of an element, which is its zero-based index in the sorted sequence of elements. 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 FHSVXQ%None 4FHSVX NoneHSVX6primitive-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)& traversal over the values in the map.primitive-containersO(n)6 traversal over the values in the map, using the keys.primitive-containersO(n) like , but discards the results.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-containersmapNoneHSVXyprimitive-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)& traversal over the values in the map.primitive-containersO(n)6 traversal over the values in the map, using the keys.primitive-containersO(n) like , but discards the results.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-containersmap None FHSVXprimitive-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      &None FHSVXS 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  .  NoneFHSVXprimitive-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   !"#$  ! "#$NoneHSVX%primitive-containersA map from keys k to values v4. The key type and the value type must both have b 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.0primitive-containersO(1)# The number of elements in the map.1primitive-containersO(n) Map over the values in the map.2primitive-containersO(n)/ Drop elements for which the predicate returns .3primitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.4primitive-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.5primitive-containersThis has the same behavior as 4r. 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.6primitive-containersO(n)` Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.7primitive-containersO(n)a Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.8primitive-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.9primitive-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)& traversal over the values in the map.;primitive-containersO(n)6 traversal over the values in the map, using the keys.<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 pairs4primitive-containersModification-applying functionprimitive-containersMap5primitive-containersModification-applying functionprimitive-containersMap6primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap7primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap8primitive-containers reductionprimitive-containersmap9primitive-containers reductionprimitive-containersmap<primitive-containers reductionprimitive-containersmap=primitive-containers reduction primitive-containersmap>primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap?primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap%&'()*+,-./0123456789:;<=>?@%'(&012345>?=6789:;<)*,+-./@NoneHSVXV Gprimitive-containersA map from keys k to values v. The key type must have a b. instance and the value type is unconstrained.Iprimitive-containersO(log n)& Lookup the value at a key in the map.Jprimitive-containersThe empty map.Kprimitive-containersO(1)$ Create a map with a single element.Lprimitive-containersO(n). A list of key-value pairs in ascending order.Mprimitive-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.Nprimitive-containers O(n*log n)( This function has the same behavior as M 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 GS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.Oprimitive-containers O(n*log n)( This function has the same behavior as M#, but it combines values with the 4 instances instead of choosing the last occurrence.Pprimitive-containers O(n*log n)( This function has the same behavior as N#, but it combines values with the 4 instances instead of choosing the last occurrence.Qprimitive-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.Rprimitive-containersO(1)# The number of elements in the map.Sprimitive-containersO(n) Map over the values in the map.Tprimitive-containersO(n)/ Drop elements for which the predicate returns .Uprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.Vprimitive-containersO(n)? Map over the elements with access to their corresponding keys.Xprimitive-containersO(n)& traversal over the values in the map.Yprimitive-containersO(n)6 traversal over the values in the map, using the keys.Zprimitive-containersO(n) like Y, but discards the results.[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.aprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.bprimitive-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.cprimitive-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.dprimitive-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. eprimitive-containersO(1) Get the keys from the map.gprimitive-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.iprimitive-containersO(1)4 The values in a map. This is a zero-cost operation.qprimitive-containers1This fails the functor laws since fmap is strict.Nprimitive-containersexpected size of resulting Gprimitive-containerskey-value pairsPprimitive-containersexpected size of resulting Gprimitive-containerskey-value pairs^primitive-containers reductionprimitive-containersmap_primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap`primitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapaprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap#GHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghi#GHJKIRSTUVefghW`_abc[\]^XYZLMONPQidNoneHSVX#rprimitive-containersA map from keys k to values v4. The key type and the value type must both have b instances.sprimitive-containersThe empty diet map.tprimitive-containersO(log n)& Lookup the value at a key in the map.uprimitive-containersO(1)$ Create a map with a single element.vprimitive-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.wprimitive-containers O(n*log n)( This function has the same behavior as v 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 rS. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.xprimitive-containers O(n*log n)( This function has the same behavior as v#, but it combines values with the 4 instances instead of choosing the last occurrence.yprimitive-containers O(n*log n)( This function has the same behavior as w#, but it combines values with the 4 instances instead of choosing the last occurrence.zprimitive-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.}primitive-containersO(n) Map over the values in the map.~primitive-containersO(n)M Map over the values in the map. The resulting map contains lifted values.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 ,. 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)6 traversal over the values in the map, using the keys.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 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. wprimitive-containersexpected size of resulting rprimitive-containerskey-value pairsyprimitive-containersexpected size of resulting rprimitive-containerskey-value pairsprimitive-containersModification-applying functionprimitive-containersMapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reduction primitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmaprstuvwxyz{|}~rsut|}~vxwyz{'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 .NoneFHSVXprimitive-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 boundNoneFHSVX~primitive-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.NoneHSVX2Zprimitive-containersA map from keys k to values v. The key type must have a ) instance and the value type must have a b 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)& traversal over the values in the map.primitive-containersO(n)6 traversal over the values in the map, using the keys.primitive-containersO(n) like , but discards the results.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-containersmapNoneHSVX~Pprimitive-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)& traversal over the values in the map.primitive-containersO(n)6 traversal over the values in the map, using the keys.primitive-containersO(n) like , but discards the results.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 FHSVXNone FHSVXprimitive-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()*+,-./0123456,789:;<=>?@++,-89ABCDEFGH23I45++,-J89ABCDEFGH23I456.,789:;KL<=>?@+,-523466M,78NOPKQRSTUVWXYJZ<@=>?6M,78NOPKQRSTUVWXYJ[<@=>? 6 M , 7 8 N O P K Q R S T U V W X Y J [ < @ = > ?#+#J#8#D#R#\ A B ] ^ . _ 0 - ` , X a T b P c$6 , 7 J 8%6%. 6 6 . 7 , J 8 9 : L ; X Q d e f g h i W j k l m n o p Y @ < q ? = >66.7,J89:L;XQdefghiWjklmnoprY@<q?=>s , t u 7 J 8&+&J&8.A_B]^v-0,wxXDR\aTbPcy67.,J89:;LzXQde{|Wjklghimno}@<q?=>667.,J89:;LXQde~fghiWjklnVom}rY@<q?=>s6.7,89:;LzXQde{Wjklghimno}@<q?=>'+'J'8-.0,XAB]^vbDTR\aPc+JL-,XbDTR\aPc5I4367.,89:;LXQdeghiWjklmno}@<q?=>667.,89:;LXQdeghiWjklmno}p@<q?=>,7J8,tu7J8,++./01-,GEF++.98-CABXJD6.Q98;:,7JL,+.- 6 X K Q g P M . , 7 p U V W R S T J 8 Y !T!!+!+!!0!.!!!Q!9!8!v!A!]!B!!J!b!-!`!!,!w!x!X!D!R!\!a!S!P!c!^"~"d""e"}""6"."0","""9"8";":"Q""J"V""{"|""""f""""7"X""W"j"k"g"h"i"l"m"n"o""L"z"r"Y"#+#$J$8$.$,$7%J%8%,%t%u%7&HT&+'H'+'1primitive-containers-0.4.1-JYxoXQzG2NjBQHqsDIP3o8Data.Continuous.Set.Lifted"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.Map.Interval.DBTSULData.Map.Interval.DBTSUUData.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.UnliftedData.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 $fShowSetMaplookupfromList fromListNfromListAppendfromListAppendN $fIsListMap $fMonoidMap$fSemigroupMap$fEqMap $fShowMap difference intersectionnegatefoldraboveInclusivebelowInclusivebetweenInclusive $fIsListSet$fOrdSettoList mapBijectionfromSetpuretraverseBijectionPtraverseBijection traverse_mapfoldl'foldlM'foldMap unionWith foldrWithKeyfoldlWithKeyM'sizeelems $fFoldableMapfromLiftedLiftedfoldr' intersectssubset\\ lookupIndexfoldMap'toArray itraverse_mapMaybemapMaybeWithKey appendWithKeytraversetraverseWithKeytraverseWithKey_foldrWithKeyM'foldlMapWithKeyM'foldrMapWithKeyM'foldMapWithKey' foldlWithKey' foldrWithKey'union$fOrdMapkeys $fFunctorMap antisingletonfromPolarities enumFromTo doubleton tripleton mapMonotonicfromSetP adjustManyadjustManyInlineunsafeFreezeZip mapWithKeyfoldMapWithKeyintersectionWithintersectionsWithrestrict $fNFDataMap mapLifted mapMaybeP fromNonEmptytoSet $fHashableSet concatSized concatSized1 infinitiesequalsappend showsPrecuncheckedSingletonaboveExclusivebelowExclusiveconcat indexLower indexUpperslicelocateliftShowsPrec2ghc-prim GHC.ClassesEq traverseP convertKeysconvertKeysValues(primitive-0.7.0.0-9xMM76CsovTEGnXCHiCdRJData.Primitive.TypesPrimliftHashWithSaltcomparebase GHC.MaybeNothingunsafeZipPresortedappendRightBiased appendWithsizeKeysrnfgetSetGHC.Base Semigroup Data.Foldable0primitive-unlifted-0.1.2.0-Cj2PXuMmRKdIxSd3izdqfData.Primitive.Unlifted.Class PrimUnlifted