h&]      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                                                                                                                                           Safe-Inferredprimitive-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-containersThis function is likely to be used for things like intersection where the zero-sized element is not an identity but a zero. Safe-Inferred  primitive-containers lower bound, Nothing means -Dprimitive-containers upper bound, Nothing means +Dprimitive-containers!upper bound for negative infinityprimitive-containers!lower bound for positive infinite Safe-Inferred 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-Inferred  d Safe-Inferredprimitive-containersThe empty diet map.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-containersMap an equality morphism over the values in a diet map. An bijection f must satisfy the law: D x y. x == y C f x == f y%Since this does not actually use the = constraint on the new value type, it is lazy in the values.primitive-containersinclusive lower boundprimitive-containersinclusive upper boundprimitive-containersvalueprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers bijection   Safe-Inferred primitive-containersMonoidal fold over the elements in the set. This is lazy in the accumulator.primitive-containerssaltprimitive-containersset" Safe-Inferred mprimitive-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-containersSort 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.If either of these conditions is not met, this function will introduce undefined behavior or segfaults.1 Safe-Inferredprimitive-containersConvert a set to a list. The elements are given in ascending order.primitive-containersConvert a list to a set.primitive-containersRight 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. ! Safe-Inferredz"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 empty)primitive-containers3Test whether or not an element is present in a set.*primitive-containersO(log n) . Lookup the index 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) Convert a set to an array. The elements are given in ascending order. This function is zero-cost.0primitive-containers&Traverse a set, discarding the result.1primitive-containers7Traverse a set with the indices, discarding the result. !"#$%&'()*+,-./01&+()*,"'#%$/ !-.01 Safe-Inferred 2 Safe-Inferred 2345623456 Safe-Inferred 8\78 Safe-Inferred/-9primitive-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 9. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.Aprimitive-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.Bprimitive-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.Cprimitive-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.Dprimitive-containersO(1)# The number of elements in the map.Eprimitive-containersO(n) Map over the values in the map.Fprimitive-containersO(n)/ Drop elements for which the predicate returns .Gprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.Iprimitive-containersO(n)& traversal over the values in the map.Jprimitive-containersO(n)6 traversal over the values in the map, using the keys.Kprimitive-containersO(n) like J, but discards the results.Lprimitive-containersO(n) Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.Mprimitive-containersO(n) Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.Nprimitive-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.Oprimitive-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.Pprimitive-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.Qprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.Rprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.Sprimitive-containersO(n+m) The expression (S t1 t2") takes the left-biased union of t1 and t2 . It prefers t1% when duplicate keys are encountered.Tprimitive-containersO(1)4 The values in a map. This is a zero-cost operation. @primitive-containersexpected size of resulting 9primitive-containerskey-value pairsCprimitive-containersexpected size of resulting 9primitive-containerskey-value pairsLprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapMprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapNprimitive-containers reductionprimitive-containersmapOprimitive-containers reductionprimitive-containersmapPprimitive-containers reduction primitive-containersmapQprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapRprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap9:;<=>?@ABCDEFGHIJKLMNOPQRST9:;=?A@CBT Safe-InferredA~[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.aprimitive-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.bprimitive-containers O(n*log n)( This function has the same behavior as a 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 [. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time.cprimitive-containers O(n*log n)( This function has the same behavior as a#, but it combines values with the 4 instances instead of choosing the last occurrence.dprimitive-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.eprimitive-containers O(n*log n)( This function has the same behavior as b#, but it combines values with the 4 instances instead of choosing the last occurrence.fprimitive-containersO(1)# The number of elements in the map.gprimitive-containersO(n) Map over the values in the map.hprimitive-containersO(n)/ Drop elements for which the predicate returns .iprimitive-containersO(n)/ Drop elements for which the predicate returns ,. The predicate is given access to the key.kprimitive-containersO(n)& traversal over the values in the map.lprimitive-containersO(n)6 traversal over the values in the map, using the keys.mprimitive-containersO(n) like l, but discards the results.nprimitive-containersO(n) Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.oprimitive-containersO(n) Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.pprimitive-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.qprimitive-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.rprimitive-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.sprimitive-containersO(n)> Left fold over the keys and values with a strict accumulator.tprimitive-containersO(n)? Right fold over the keys and values with a strict accumulator.uprimitive-containersO(n+m) The expression (u t1 t2") takes the left-biased union of t1 and t2 . It prefers t1% when duplicate keys are encountered.vprimitive-containersO(1)4 The values in a map. This is a zero-cost operation.wprimitive-containersO(1)4 The values in a map. This is a zero-cost operation. bprimitive-containersexpected size of resulting [primitive-containerskey-value pairseprimitive-containersexpected size of resulting [primitive-containerskey-value pairsnprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapoprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmappprimitive-containers reductionprimitive-containersmapqprimitive-containers reductionprimitive-containersmaprprimitive-containers reduction primitive-containersmapsprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmaptprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap[\]^_`abcdefghijklmnopqrstuvw[\]_^fghijustrklmnopq`acbedvw Safe-Inferred D&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 absences7878 Safe-Inferred G~primitive-containersA set of elements.primitive-containersConvert 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). 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  fromListN on a presorted list and passing the correct size size of the resulting . However, even if an incorrect size is given to this function, it will still correctly convert the list into a . Safe-InferredNprimitive-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-containersThe 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-containersRight 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) 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-containersMap over the elements of a set. The provided function must be monotonic.primitive-containersInclusive lower boundprimitive-containersInclusive upper bound  Safe-InferredgYprimitive-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 . 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.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-containersUpdate the values at any number of keys. This is done on in a buffer without building intermediate maps. Example use: adjustMany (\adjust -> do adjust 2 (\x -> pure (x + 1)) adjust 3 (\_ -> pure 42) ) myMapThis increments by 1 the value associated with key 2. Then, it replaces with 42 the value associated with key 3.primitive-containersThis has the same behavior as . However, it will be inlined rather than specialized. The can prevent needless boxing in the callback. Use  -ddump-simpl and standard profiling techniques to figure out if this function actually helps you.primitive-containersO(n) Left monadic fold over the keys and values of the map. This fold is strict in the accumulator.primitive-containersO(n) 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)& 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) 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-containersModification-applying functionprimitive-containersMapprimitive-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 reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap  Safe-Inferred~, primitive-containersA map from keys k to values v. The key type must have a . instance and the value type is unconstrained.primitive-containersO(log n)& Lookup the value at a key in the map.primitive-containersThe empty map.primitive-containersO(1)$ Create a map with a single element.primitive-containersO(n). A list of key-value pairs in ascending order.primitive-containers O(n*log n) Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.primitive-containers O(n*log n)( This function has the same behavior as  regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the . 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)? Map over the elements with access to their corresponding keys.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) Right monadic fold over the keys and values of the map. This fold is strict in the accumulator.primitive-containersO(n) Monadic left fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the left after each reduction.primitive-containersO(n) Monadic right fold over the keys and values of the map with a strict monoidal accumulator. The monoidal accumulator is appended to the right after each reduction.primitive-containersO(n)> Left fold over the keys and values with a strict accumulator.primitive-containersO(n)= Right fold over the keys and values with a lazy accumulator.primitive-containersO(n)? Right fold over the keys and values with a strict accumulator.primitive-containersO(n) Fold over the keys and values of the map with a lazy monoidal accumulator. This function does not have left and right variants since the associativity required by a monoid instance means that both variants would always produce the same result.primitive-containersO(n) Fold over the keys and values of the map with a strict monoidal accumulator. This function does not have left and right variants since the associativity required by a monoid instance means that both variants would always produce the same result.primitive-containers O(n*log n) 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.primitive-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.primitive-containersO(1)4 The values in a map. This is a zero-cost operation.primitive-containers1This fails the functor laws since fmap is strict.primitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containersexpected size of resulting primitive-containerskey-value pairsprimitive-containers reductionprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmapprimitive-containers reductionprimitive-containersinitial accumulatorprimitive-containersmap##  Safe-Inferreduprimitive-containersA map from keys k to values v4. The key type and the value type must both have  instances.primitive-containersThe empty diet map.primitive-containersO(log n)& Lookup the value at a key in the map.primitive-containersO(1)$ Create a map with a single element.primitive-containers O(n*log n) Create a map from a list of key-value pairs. If the list contains more than one value for the same key, the last value is retained. If the keys in the argument are in nondescending order, this algorithm runs in O(n) time instead.primitive-containers O(n*log n)( This function has the same behavior as  regardless of whether or not the expected size is accurate. Additionally, negative sizes are handled correctly. The expected size is used as the size of the initially allocated buffer when building the . 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.primitive-containersO(n) Map over the values in the map.primitive-containersO(n) 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-containersUpdate the values at any number of keys. This is done on in a buffer without building intermediate maps. Example use: adjustMany (\adjust -> do adjust 2 (\x -> pure (x + 1)) adjust 3 (\_ -> pure 42) ) myMapThis 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) 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) 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-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-containersmap Safe-Inferredprimitive-containersO(n) 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). 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  fromListN on a presorted list and passing the correct size size of the resulting . However, even if an incorrect size is given to this function, it will still correctly convert the list into a .  Safe-Inferredprimitive-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-containersThe set that includes all elements from the lower bound to the upper bound.primitive-containersO(1) Convert a set to an array. The elements are given in ascending order. This function is zero-cost.primitive-containersRight fold over the elements in the set. This is lazy in the accumulator.primitive-containersMonoidal 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 bound  Safe-Inferred"primitive-containersO(n) 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 Nothing if the set is empty. The resulting non-empty set shares internal represention as the argument.primitive-containersO(0) 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) Convert a set to an array. The elements are given in ascending order. This function is zero-cost.primitive-containersRight fold over the elements in the set. This is lazy in the accumulator.primitive-containersMonoidal 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. Safe-Inferredprimitive-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 . 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) 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) 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-containersmap Safe-Inferredprimitive-containersA map from keys k to values v. The key type must have a ) instance and the value type must have a Prim instance.The 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 . 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) 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) 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-containersmap Safe-Inferred ~22 Safe-Inferred 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 absences7878 !"#$%&'()*" +,-./0123456,789:;<=">$!? @ABCDE* +6,*"**"+ 6,-.F/@GHIJKLMNOPQRSTUV51W423**"+ 6,-.F/@GHIJKLMNOPQRSTUXV51W423Y Z[+6,6,":>;<=\!$ ]^@789ABCDE_ * + " 6 , - . / F ` @ G H I a b N O P Q K L M R S T c 5 1 W 4 2 3 * * + " 6 , - . / F @ G H I d J K L M N O P Q S e T f R c X g h i V 5 1 W 4 2 3 j Y * " + , - . / F ` @ G k H l I a N O P Q K L M f R S T c 5 1 W 4 2 36, ! " $ @ : ; < = \ C 7 B 8 9 A D E  6 m F n ! @ C 7 B 8 9 A D E ) o ( p '*+" ,-./F@GHIKLMNOPQRSTc51W423**+" ,-./F@GHIKLMNOPQRSTcU51W423 +6, Z[+6,qr st"#$%u!v*"Gt-,/.w +u6vxyz{B|u$"t}G-,\:<;v6C!?w ]^@789A~DE=dHlIc*"$ t}-,/.Gv6efabwhJug+@NOPKLMQRSTiF`XV6," +6, Z[+B1primitive-containers-0.5.0-LXfQc062naGGYXdrz315D4Data.Continuous.Set.Lifted#Data.Diet.Map.Strict.Unboxed.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.UnliftedData.Set.UnliftedData.Set.NonEmpty.UnliftedData.Map.Unlifted.UnboxedData.Map.Unlifted.LiftedData.Map.Subset.Strict.UnliftedData.Map.Subset.Lazy.UnliftedData.ConcatenationData.Continuous.Set.InternalData.Diet.Map.Strict.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 mapBijection $fIsListMap $fMonoidMap$fSemigroupMap$fEqMap $fShowMaptoListfoldrfoldl'foldr' difference intersection intersectssubset\\ lookupIndexsizefoldMap'foldMaptoArray traverse_ itraverse_fromSetmapmapMaybemapMaybeWithKey appendWithKeytraversetraverseWithKeytraverseWithKey_foldlWithKeyM'foldrWithKeyM'foldlMapWithKeyM'foldrMapWithKeyM'foldMapWithKey' foldlWithKey' foldrWithKey'unionelems$fOrdMapkeys $fFunctorMap antisingletonfromPolarities enumFromTo doubleton tripleton mapMonotonicfromSetP adjustManyadjustManyInlineunsafeFreezeZip mapWithKey foldrWithKeyfoldMapWithKeyintersectionWithintersectionsWithrestrict $fNFDataMap mapLifted mapMaybeP fromNonEmptytoSet$fOrdSet $fHashableSet concatSized concatSized1 infinitiesequalsappend showsPrecconcatliftShowsPrec2ghc-prim GHC.ClassesEqliftHashWithSaltcomparefoldlM'base GHC.MaybeNothingunsafeZipPresortedappendRightBiased appendWithsizeKeysrnfgetSetGHC.Base Semigroup $fIsListSet Data.Foldable'primitive-0.7.4.0-5Mou7sRsTgfjuEOfjOZOzData.Primitive.TypesPrim1primitive-unlifted-0.1.3.1-GTrjFSvColS3UXOruxVk4JData.Primitive.Unlifted.Class PrimUnlifted