h*_      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 0.2.20  Safe-Inferred   unordered-containersCreate a new mutable array of specified size, in the specified state thread, with each element containing the specified initial value. unordered-containersWhen  is available, the returned array is the same as the array given, as it is shrunk in place. Otherwise a copy is made.unordered-containersUnsafely copy the elements of an array. Array bounds are not checked.unordered-containersUnsafely copy the elements of an array. Array bounds are not checked.unordered-containersO(n) Insert an element at the given position in this array, increasing its size by one.unordered-containersO(n) Insert an element at the given position in this array, increasing its size by one.unordered-containersO(n)8 Update the element at the given position in this array.unordered-containersO(n)8 Update the element at the given position in this array.unordered-containersO(n) Update the element at the given position in this array, by applying a function to it. Evaluates the element to WHNF before inserting it into the array. unordered-containersO(1) Update the element at the given position in this array, without copying.&unordered-containers=Verifies that a predicate holds for all elements of an array.(unordered-containersO(n) Delete an element at the given position in this array, decreasing its size by one.unordered-containersO(n) Delete an element at the given position in this array, decreasing its size by one.*unordered-containersStrict version of ).0unordered-containers1unordered-containers0   ($!#"%&')*./-+, 0   ($!#"%&')*./-+,  Safe-Inferred 6465465 Safe-Inferred!016?]:unordered-containers: values correspond to the level of the tree that we're currently operating at. At the root level the : is 0!. For the subsequent levels the : values are , 2* etc.,Valid values are non-negative and less than bitSize (0 :: Word).;unordered-containersA bitmap as contained by a ? node, or a  corresponding to a A node.Only the lower 1 bits are used. The remaining bits must be zeros.<unordered-containers?This type is used to store the hash of a key, as produced with E.=unordered-containersA map from keys to values. A map cannot contain duplicate keys; each key can map to at most one value.>unordered-containers Invariants:> is not a valid sub-node. It can only appear at the root. (INV1)?unordered-containers Invariants:Only the lower  maxChildren bits of the ;: may be set. The remaining upper bits must be 0. (INV2)The array of a ?' node stores at least 1 and at most  - 1 sub-nodes. (INV3)The number of sub-nodes is equal to the number of 1-bits in its ;. (INV4)If a ?8 node has only one sub-node, this sub-node must be a ? or a A node. (INV5)@unordered-containers Invariants:The location of a C or B1 node in the tree must be compatible with its <1. (INV6) (TODO: Document this properly (#425))The < of a C node must be the E of its key. (INV7)Aunordered-containers Invariants:The array of a A node stores exactly  sub-nodes. (INV8)Bunordered-containers Invariants:The location of a C or B1 node in the tree must be compatible with its <1. (INV6) (TODO: Document this properly (#425))The array of a B1 node must contain at least two sub-nodes. (INV9)The E of each key in a B3 node must be the one stored in the node. (INV7)No two keys stored in a B$ can be equal according to their  instance. (INV10)Eunordered-containersConvenience function. Compute a hash value for the given value.unordered-containersHelper to get Cs and B s as a list.Hunordered-containersHelper function to detect Cs and Bs.Iunordered-containersO(1) Construct an empty map.Junordered-containersO(1)' Construct a map with a single element.Kunordered-containersO(1) Return  if this map is empty,  otherwise.Lunordered-containersO(n)5 Return the number of key-value mappings in this map.Munordered-containers O(\log n) Return . if the specified key is present in the map,  otherwise.Nunordered-containers O(\log n)< Return the value to which the specified key is mapped, or - if this map contains no mapping for the key.Ounordered-containerslookup' is a version of lookup that takes the hash separately. It is used to implement alterF.R unordered-containers O(\log n)< Return the value to which the specified key is mapped, or - if this map contains no mapping for the key.This is a flipped version of N.S unordered-containers O(\log n) Return the value to which the specified key is mapped, or the default value if this map contains no mapping for the key.Tunordered-containers O(\log n) Return the value to which the specified key is mapped, or the default value if this map contains no mapping for the key.DEPRECATED: lookupDefault is deprecated as of version 0.2.11, replaced by S.Uunordered-containers O(\log n)? Return the value to which the specified key is mapped. Calls - if this map contains no mapping for the key.Vunordered-containers Create a B value with two C values.Wunordered-containers Create a ? or A node.Xunordered-containers O(\log n) Associate the specified value with the specified key in this map. If this map previously contained a mapping for the key, the old value is replaced.\unordered-containers!In-place update version of insert]unordered-containersCreate a map from two key-value pairs which hashes don't collide. To enhance sharing, the second key-value pair is represented by the hash of its key and a singleton HashMap pairing its key with its value.Note: to avoid silly thunks, this function must be strict in the key. See issue #232. We don't need to force the HashMap argument because it's already in WHNF (having just been matched) and we just put it directly in an array.^unordered-containers O(\log n) Associate the value with the key in this map. If this map previously contained a mapping for the key, the old value is replaced by the result of applying the given function to the new and old value. Example: 2insertWith f k v map where f new old = new + old_unordered-containersinsertModifying is a lot like insertWith; we use it to implement alterF. It takes a value to insert when the key is absent and a function to apply to calculate a new value when the key is present. Thanks to the unboxed unary tuple, we avoid introducing any unnecessary thunks in the tree.unordered-containers%In-place update version of insertWith`unordered-containers O(\log n) Remove the mapping for the specified key from this map if present.bunordered-containersDelete optimized for the case when we know the key is in the map.It is only valid to call this when the key exists in the map and you know the hash collision position if there was one. This information can be obtained from Q1. If there is no collision, pass (-1) as collPos.cunordered-containers O(\log n) Adjust the value tied to a given key in this map only if it is present. Otherwise, leave the map alone.dunordered-containers Much like c, but not inherently leaky.eunordered-containers O(\log n) The expression (e f k map) updates the value x at k (if it is in the map). If (f x) is $, the element is deleted. If it is ( y) , the key k is bound to the new value y.funordered-containers O(\log n) The expression (f f k map) alters the value x at k, or absence thereof.f can be used to insert, delete, or update a value in a map. In short: N k (f f k m) = f (N k m) g unordered-containers O(\log n) The expression (g f k map) alters the value x at k, or absence thereof.g; can be used to insert, delete, or update a value in a map.Note: g is a flipped version of the at combinator from  https://hackage.haskell.org/package/lens/docs/Control-Lens-At.html#v:atControl.Lens.At.unordered-containersThis is the default version of alterF that we use in most non-trivial cases. It's called "eager" because it looks up the given key in the map eagerly, whether or not the given function requires that information.h unordered-containers O(n \log m) Inclusion of maps. A map is included in another map if the keys are subsets and the corresponding values are equal: isSubmapOf m1 m2 = keys m1 `isSubsetOf` keys m2 && and [ v1 == v2 | (k1,v1) <- toList m1; let v2 = m2 ! k1 ]Examples:fromList [(1,'a')] `isSubmapOf` fromList [(1,'a'),(2,'b')]True:fromList [(1,'a'),(2,'b')] `isSubmapOf` fromList [(1,'a')]Falsei unordered-containers O(n \log m) Inclusion of maps with value comparison. A map is included in another map if the keys are subsets and if the comparison function is true for the corresponding values: isSubmapOfBy cmpV m1 m2 = keys m1 `isSubsetOf` keys m2 && and [ v1 `cmpV` v2 | (k1,v1) <- toList m1; let v2 = m2 ! k1 ]ExamplesisSubmapOfBy (<=) (fromList [(1,'a')]) (fromList [(1,'b'),(2,'c')])TrueisSubmapOfBy (<=) (fromList [(1,'b')]) (fromList [(1,'a'),(2,'c')])Falseunordered-containers O(\min n m))8 Checks if a bitmap indexed node is a submap of another.junordered-containersO(n+m) The union of two maps. If a key occurs in both maps, the mapping from the first will be the mapping in the result.Examples?union (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])"fromList [(1,'a'),(2,'b'),(3,'d')]kunordered-containersO(n+m) The union of two maps. If a key occurs in both maps, the provided function (first argument) will be used to compute the result.lunordered-containersO(n+m) The union of two maps. If a key occurs in both maps, the provided function (first argument) will be used to compute the result.munordered-containersStrict in the result of f.nunordered-containers 1) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")])fromList [(1,"c")]mapKeys (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")])fromList [(3,"c")]tunordered-containers O(n \log m) Difference of two maps. Return elements of the first map not existing in the second.uunordered-containers O(n \log m) Difference with a combining function. When two equal keys are encountered, the combining function is applied to the values of these keys. If it returns , the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y.vunordered-containers O(n \log m) Intersection of two maps. Return elements of the first map for keys existing in the second.wunordered-containers O(n \log m) Intersection of two maps. If a key occurs in both maps the provided function is used to combine the values from the two maps.xunordered-containers O(n \log m) Intersection of two maps. If a key occurs in both maps the provided function is used to combine the values from the two maps.unordered-containers Say we have  1 2 3 4  and we search for 3#. Then we can mutate the array to  undefined 2 1 4  We don't actually need to write undefined, we just have to make sure that the next search starts 1 after the current one.zunordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the left-identity of the operator). Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.{unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator). Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.|unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the left-identity of the operator). Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.}unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator). Each application of the operator is evaluated before using the result in the next application. This function is strict in the starting value.~unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the left-identity of the operator).unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the right-identity of the operator).unordered-containersO(n) Reduce this map by applying a binary operator to all elements, using the given starting value (typically the left-identity of the operator).unordered-containersO(n) Reduce the map by applying a function to each element and combining the results with a monoid operation.unordered-containersO(n) Transform this map by applying a function to every value and retaining only some of them.unordered-containersO(n) Transform this map by applying a function to every value and retaining only some of them.unordered-containersO(n) Filter this map by retaining only elements satisfying a predicate.unordered-containersCommon implementation for  and 2, allowing the former to former to reuse terms.unordered-containersO(n) Filter this map by retaining only elements which values satisfy a predicate.unordered-containersO(n) Return a list of this map's keys. The list is produced lazily.unordered-containersO(n) Return a list of this map's values. The list is produced lazily.unordered-containersO(n) Return a list of this map's elements. The list is produced lazily. The order of its elements is unspecified.unordered-containersO(n) Construct a map with the supplied mappings. If the list contains duplicate mappings, the later mappings take precedence.unordered-containers O(n \log n) Construct a map from a list of elements. Uses the provided function f" to merge duplicate entries with (f newVal oldVal).Examples Given a list xs, create a map with the number of occurrences of each element in xs: let xs = ['a', 'b', 'a'] in fromListWith (+) [ (x, 1) | x <- xs ] = fromList [('a', 2), ('b', 1)] Given a list of key-value pairs xs :: [(k, v)]/, group all values by their keys and return a  HashMap k [v]. let xs = [('a', 1), ('b', 2), ('a', 3)] in fromListWith (++) [ (k, [v]) | (k, v) <- xs ] = fromList [('a', [3, 1]), ('b', [2])]Note that the lists in the resulting map contain elements in reverse order from their occurrences in the original list.More generally, duplicate entries are accumulated as follows; this matters when f' is not commutative or not associative. fromListWith f [(k, a), (k, b), (k, c), (k, d)] = fromList [(k, f d (f c (f b a)))] unordered-containers O(n \log n) Construct a map from a list of elements. Uses the provided function to merge duplicate entries.ExamplesGiven a list of key-value pairs where the keys are of different flavours, e.g: data Key = Div | Suband the values need to be combined differently when there are duplicates, depending on the key: #combine Div = div combine Sub = (-)then fromListWithKey can be used as follows: fromListWithKey combine [(Div, 2), (Div, 6), (Sub, 2), (Sub, 3)] = fromList [(Div, 3), (Sub, 1)]=More generally, duplicate entries are accumulated as follows; fromListWith f [(k, a), (k, b), (k, c), (k, d)] = fromList [(k, f k d (f k c (f k b a)))]unordered-containersO(n)> Look up the value associated with the given key in an array.unordered-containersO(n) Lookup the value associated with the given key in this array. Returns  if the key wasn't found.unordered-containersO(n*m): Check if the first array is a subset of the second array.unordered-containersO(n)8 Update the element at the given position in this array.unordered-containersO(n)8 Update the element at the given position in this array.unordered-containersO(n) Update the element at the given position in this array, by applying a function to it.unordered-containersUnsafely clone an array of (2^bitsPerSubkey) elements. The length of the input array is not checked.unordered-containersNumber of bits that are inspected at each level of the hash tree.This constant is named t in the original Ideal Hash Trees paper.unordered-containersThe size of a A node, i.e. 2 ^ .unordered-containersBit mask with the lowest  bits set, i.e. 0b11111.unordered-containersGiven a < and a : that indicates the level in the tree, compute the index into a A node or into the bitmap of a ? node.index 0b0010_0010 0 0b0000_0010unordered-containersGiven a < and a : that indicates the level in the tree, compute the bitmap that contains only the  of the hash at this level.4The result can be used for constructing one-element ? nodes or to check whether a ?% node may possibly contain the given <.mask 0b0010_0010 00b0100unordered-containersThis array index is computed by counting the number of 1-bits below the  represented by the mask.#sparseIndex 0b0110_0110 0b0010_00002unordered-containersA bitmap with the # least significant bits set, i.e.  0xFF_FF_FF_FF.unordered-containers Increment a :" for use at the next deeper level.unordered-containersCheck if two the two arguments are the same value. N.B. This function might give false negatives (due to GC moving objects.)unordered-containersunordered-containersunordered-containersunordered-containers.The ordering is total and consistent with the  instance. However, nothing else about the ordering is specified, and it may change from version to version of either this package or of hashable.unordered-containers5Note that, in the presence of hash collisions, equal HashMap?s may behave differently, i.e. extensionality may be violated:"data D = A | B deriving (Eq, Show)5instance Hashable D where hashWithSalt salt _d = saltx = fromList [(A,1), (B,2)]y = fromList [(B,2), (A,1)]x == yTruetoList x [(A,1),(B,2)]toList y [(B,2),(A,1)]In general, the lack of extensionality can be observed with any function that depends on the key ordering, such as folds and traversals.unordered-containers = I = jIf a key occurs in both maps, the mapping from the first will be the mapping in the result.Examplesmappend (fromList [(1,'a'),(2,'b')]) (fromList [(2,'c'),(3,'d')])"fromList [(1,'a'),(2,'b'),(3,'d')]unordered-containers = jIf a key occurs in both maps, the mapping from the first will be the mapping in the result.Examples8fromList [(1,'a'),(2,'b')] <> fromList [(2,'c'),(3,'d')]"fromList [(1,'a'),(2,'b'),(3,'d')] unordered-containersunordered-containersunordered-containersunordered-containersSunordered-containersDefault value to return.Tunordered-containersDefault value to return.unordered-containers Bitmap of a ? nodeunordered-containersOne-bit  corresponding to the  of a hashunordered-containersIndex into the array of the ? node=>@?ABCDIJKLMNRSTUX^\`cefghijklnoqprstuvwxy{z}|~<;:WVEH]mGFQ789PYaOZ[b_d=>@?ABCDIJKLMNRSTUX^\`cefghijklnoqprstuvwxy{z}|~<;:WVEH]mGFQ789PYaOZ[b_dU9  Safe-Inferred`@unordered-containersThe bits we already know, starting from the lower bits. The unknown upper bits are 0.unordered-containersThe number of bits known.unordered-containers A part of a < with  bits.unordered-containers-An error corresponding to a broken invariant.See =) for the documentation of the invariants. 2010-2012 Johan Tibell BSD-stylejohan.tibell@gmail.comportable Trustworthyzunordered-containersO(1)' Construct a map with a single element.unordered-containers O(\log n) Associate the specified value with the specified key in this map. If this map previously contained a mapping for the key, the old value is replaced.unordered-containers O(\log n) Associate the value with the key in this map. If this map previously contained a mapping for the key, the old value is replaced by the result of applying the given function to the new and old value. Example: 2insertWith f k v map where f new old = new + oldunordered-containers%In-place update version of insertWithunordered-containers O(\log n) Adjust the value tied to a given key in this map only if it is present. Otherwise, leave the map alone.unordered-containers O(\log n) The expression ( f k map) updates the value x at k (if it is in the map). If (f x) is $, the element is deleted. If it is ( y) , the key k is bound to the new value y.unordered-containers O(\log n) The expression ( f k map) alters the value x at k, or absence thereof. can be used to insert, delete, or update a value in a map. In short: lookup k ( f k m) = f (lookup k m)  unordered-containers O(\log n) The expression ( f k map) alters the value x at k, or absence thereof.; can be used to insert, delete, or update a value in a map.Note:  is a flipped version of the at combinator from  https://hackage.haskell.org/package/lens/docs/Control-Lens-At.html#v:atControl.Lens.At.unordered-containersThis is the default version of alterF that we use in most non-trivial cases. It's called "eager" because it looks up the given key in the map eagerly, whether or not the given function requires that information.unordered-containersO(n+m) The union of two maps. If a key occurs in both maps, the provided function (first argument) will be used to compute the result.unordered-containersO(n+m) The union of two maps. If a key occurs in both maps, the provided function (first argument) will be used to compute the result.unordered-containersO(n): Transform this map by applying a function to every value.unordered-containersO(n): Transform this map by applying a function to every value.unordered-containersO(n) Transform this map by applying a function to every value and retaining only some of them.unordered-containersO(n) Transform this map by applying a function to every value and retaining only some of them.unordered-containersO(n) Perform an & action for each key-value pair in a = and produce a = of all the results. Each =# will be strict in all its values. traverseWithKey f = fmap ( id) . Data.HashMap.Lazy.  f Note: the order in which the actions occur is unspecified. In particular, when the map contains hash collisions, the order in which the actions associated with the keys involved will depend in an unspecified way on their insertion order.unordered-containers O(n \log m) Difference with a combining function. When two equal keys are encountered, the combining function is applied to the values of these keys. If it returns , the element is discarded (proper set difference). If it returns ( y+), the element is updated with a new value y.unordered-containersO(n+m) Intersection of two maps. If a key occurs in both maps the provided function is used to combine the values from the two maps.unordered-containersO(n+m) Intersection of two maps. If a key occurs in both maps the provided function is used to combine the values from the two maps.unordered-containers O(n \log n) Construct a map with the supplied mappings. If the list contains duplicate mappings, the later mappings take precedence.unordered-containers O(n \log n) Construct a map from a list of elements. Uses the provided function f" to merge duplicate entries with (f newVal oldVal).Examples Given a list xs, create a map with the number of occurrences of each element in xs: let xs = ['a', 'b', 'a'] in fromListWith (+) [ (x, 1) | x <- xs ] = fromList [('a', 2), ('b', 1)] Given a list of key-value pairs xs :: [(k, v)]/, group all values by their keys and return a  HashMap k [v]. let xs = ('a', 1), ('b', 2), ('a', 3)] in fromListWith (++) [ (k, [v]) | (k, v) <- xs ] = fromList [('a', [3, 1]), ('b', [2])]Note that the lists in the resulting map contain elements in reverse order from their occurrences in the original list.More generally, duplicate entries are accumulated as follows; this matters when f' is not commutative or not associative. fromListWith f [(k, a), (k, b), (k, c), (k, d)] = fromList [(k, f d (f c (f b a)))] unordered-containers O(n \log n) Construct a map from a list of elements. Uses the provided function to merge duplicate entries.ExamplesGiven a list of key-value pairs where the keys are of different flavours, e.g: data Key = Div | Suband the values need to be combined differently when there are duplicates, depending on the key: #combine Div = div combine Sub = (-)then fromListWithKey can be used as follows: fromListWithKey combine [(Div, 2), (Div, 6), (Sub, 2), (Sub, 3)] = fromList [(Div, 3), (Sub, 1)]=More generally, duplicate entries are accumulated as follows; fromListWith f [(k, a), (k, b), (k, c), (k, d)] = fromList [(k, f k d (f k c (f k b a)))]unordered-containersAppend the given key and value to the array. If the key is already present, instead update the value of the key by applying the given function to the new and old value (in that order). The value is always evaluated to WHNF before being inserted into the array.unordered-containersAppend the given key and value to the array. If the key is already present, instead update the value of the key by applying the given function to the new and old value (in that order). The value is always evaluated to WHNF before being inserted into the array.5=IKLMNRSTU`hijnostv{z}|~5=IKLMNRSTU`hijnostv{z}|~2011 Bryan O'Sullivan BSD-stylejohan.tibell@gmail.comportable Trustworthy6?*unordered-containers8A set of values. A set cannot contain duplicate values.unordered-containersO(1) Construct an empty set. HashSet.empty fromList []unordered-containersO(1)' Construct a set with a single element.HashSet.singleton 1 fromList [1]unordered-containersO(1)" Convert to set to the equivalent = with () values.#HashSet.toMap (HashSet.singleton 1)fromList [(1,())]unordered-containersO(1) Convert from the equivalent = with () values.(HashSet.fromMap (HashMap.singleton 1 ()) fromList [1] unordered-containersO(n) Produce a  of all the keys in the given =.6HashSet.keysSet (HashMap.fromList [(1, "a"), (2, "b")]fromList [1,2] unordered-containers O(n \log m) Inclusion of sets.Examples,fromList [1,3] `isSubsetOf` fromList [1,2,3]True*fromList [1,2] `isSubsetOf` fromList [1,3]Falseunordered-containersO(n+m)8 Construct a set containing all elements from both sets.To obtain good performance, the smaller set must be presented as the first argument.'union (fromList [1,2]) (fromList [2,3])fromList [1,2,3]unordered-containers fromList [2,3]fromList [1,2,3]unordered-containers5Note that, in the presence of hash collisions, equal HashSet?s may behave differently, i.e. extensionality may be violated:"data D = A | B deriving (Eq, Show)5instance Hashable D where hashWithSalt salt _d = saltx = fromList [A, B]y = fromList [B, A]x == yTruetoList x[A,B]toList y[B,A]In general, the lack of extensionality can be observed with any function that depends on the key ordering, such as folds and traversals.unordered-containersunordered-containers2011 Bryan O'Sullivan BSD-stylejohan.tibell@gmail.com provisionalportableSafe2010-2012 Johan Tibell BSD-stylejohan.tibell@gmail.com provisionalportableSafe6=IKLMNRSTU`hijnostv~{z}|6=IKLMNRSTU`hijnostv~{z}|2010-2012 Johan Tibell BSD-stylejohan.tibell@gmail.com provisionalportable Trustworthy6=IJKLMNRSTUX^`cefghijklnoqprstuvwx~{z}|6=IJKLMNRSTUX^`cefghijklnoqprstuvwx~{z}|    !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLJMNOPQRSTUVWXYZ[\]^_&`abcdef2ghij(klmnopqrstu3 vwxyz{|+,}~-.75  & e i ( k l p q u 3   x z { 5  RosSTU&23wy+,-.75    2unordered-containers-0.2.20-4wfeVF8tkn641BDEzGpHTOData.HashMap.Internal.ArrayData.HashMap.Internal.ListData.HashMap.InternalData.HashMap.StrictData.HashMap.LazyData.HashMap.Internal.Debug Data.HashSetData.HashSet.Internalunordered-containersData.HashMap.Internal.StricttraverseWithKeyMArrayunMArrayArrayunArrayunsafeSameArray sameArray1lengthlengthMnewnew_shrink singleton singletonMsnocpairreadwriteindexindex#indexM unsafeFreeze unsafeThawruncopycopyMcloneMinsertinsertMupdate updateWith' unsafeUpdateMfoldl'foldr'foldrfoldlfoldMapallthawdeletemapmap'fromList fromList'toListtraverse traverse'$fLiftBoxedRepArray$fNFData1Array $fNFDataArray $fShowArrayisPermutationByunorderedComparedeleteBy LookupResAbsentPresentShiftBitmapHashHashMapEmpty BitmapIndexedLeafFull CollisionLhash equalKeys1 equalKeysisLeafOrCollisionemptynullsizememberlookuplookup'lookupResToMaybelookupRecordCollision!?findWithDefault lookupDefault! collisionbitmapIndexedOrFullinsert' insertNewKeyinsertKeyExists unsafeInserttwo insertWithinsertModifyingdelete'deleteKeyExistsadjustadjust#alteralterF isSubmapOf isSubmapOfByunion unionWith unionWithKey unionArrayByunionscompose mapWithKeymapKeys differencedifferenceWith intersectionintersectionWithintersectionWithKeyintersectionWithKey# foldlWithKey' foldrWithKey' foldrWithKey foldlWithKeyfoldMapWithKeymapMaybeWithKeymapMaybe filterWithKey filterMapAuxfilterkeyselems fromListWithfromListWithKeyupdateOrConcatWithKeyupdate32 update32M update32With' bitsPerSubkey maxChildren subkeyMaskmask sparseIndex fullBitmap nextShiftptrEq $fNFData2Leaf $fNFData1Leaf$fLiftBoxedRepLeaf $fNFDataLeaf$fIsListHashMap$fHashableHashMap$fHashable1HashMap$fHashable2HashMap $fOrdHashMap $fOrd1HashMap $fOrd2HashMap $fEqHashMap $fEq1HashMap $fEq2HashMap$fTraversableHashMap $fShowHashMap $fReadHashMap$fRead1HashMap$fShow1HashMap$fShow2HashMap $fDataHashMap$fMonoidHashMap$fSemigroupHashMap$fBifoldableHashMap$fFoldableHashMap$fFunctorHashMap$fNFData2HashMap$fNFData1HashMap$fNFDataHashMap$fEqLeaf$fLiftBoxedRepHashMap SubHashPathSubHashErrorINV1_internal_EmptyINV2_Bitmap_unexpected_1_bitsINV3_bad_BitmapIndexed_sizeINV4_bitmap_array_size_mismatch)INV5_BitmapIndexed_invalid_single_subtreeINV6_misplaced_hashINV7_key_hash_mismatchINV8_bad_Full_sizeINV9_Collision_sizeINV10_Collision_duplicate_keyValidityInvalidValidvalid$fMonoidValidity$fSemigroupValidity $fEqValidity$fShowValidity$fEqSubHashPath$fShowSubHashPath $fEqError $fShowErrorHashSetasMaptoMapfromMapkeysSet isSubsetOf$fIsListHashSet$fHashableHashSet$fHashable1HashSet $fDataHashSet $fShowHashSet$fShow1HashSet $fReadHashSet$fMonoidHashSet$fSemigroupHashSet$fFoldableHashSet $fOrd1HashSet $fOrdHashSet $fEq1HashSet $fEqHashSet$fNFData1HashSet$fNFDataHashSet$fLiftBoxedRepHashSetghc-primGHC.PrimshrinkSmallMutableArray#updateMdeleteM GHC.ClassesEqleavesAndCollisions GHC.TypesTrueFalsebase GHC.MaybeNothingGHC.ErrerrorunsafeInsertWithJust alterFEagersubmapBitmapIndexedGHC.Base Applicative searchSwaplookupInArrayContindexOf subsetArrayclonememptymappend<> partialHash lengthInBitsupdateOrSnocWithupdateOrSnocWithKey