t      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~                                  ! " # $ % & ' ( ) * + , - . / 0 1 2 3 4 5 6 7 8 9 : ; < = > ? @ A B C D E F G H I J K L M N O P Q R S T U V W X Y Z [ \ ]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred! Safe-Inferred Safe-InferredMinimal complete definition:     or    LFor decent performance, supplying at least the following is probably a good  idea:  ,     ,  DLike an Ord instance over k, but should compare on the same type as m 1 does. In most cases this can be defined just as  const compare. !Minimal complete implementation:           , !, "  (   or ) or *  - +For decent performance, supplying at least & and ' as  well is probably a good idea. Like an 9 instance over k, but should compare on the same type as  m1 does. In most cases this can be defined just as  const (==). "Precondition: the two keys differ DStrictness can be whatever is more optimal for the map type, shouldn't  matter B  !"#$%&'()*+,-./  !"#$%&'()*+,-./ !"#$%&'()*+,-.    !"#$%&'()*+,-. Safe-Inferred0  !"#$%&'()*+,-. Safe-Inferredh      !"#$%&'()*+,-./0123P      !"#$%&'()*+,-12c      !"#$%&'()*+,-./0123 Safe-Inferredy/3The data structure itself: a map from keys of type [k] to values of type  v implemented as a trie, using map to map keys of type k to sub-tries. Regarding the instances:  The Trie class is internal, ignore it.  The  constraint for the 4& instance is misleading: it is needed  only because  is a superclass of 4.  The Foldable and 5" instances allow folding over and - traversing only the values, not the keys.  The 6 instance defines 7 as H and 8 as  0. 0O(1). The empty map. 1O(1)>. The singleton map containing only the given key-value pair. 2 O(min(m,s))9. Inserts the key-value pair into the map. If the key is D already a member of the map, the given value replaces the old one.  insert = insertWith const 3 O(min(m,s)). Like 2,, but the new value is reduced to weak head / normal form before being placed into the map.  insert' = insertWith' const 4 O(min(m,s))9. Inserts the key-value pair into the map. If the key is ; already a member of the map, the old value is replaced by  f givenValue  oldValue where f is the given function. 5 O(min(m,s)). Like 4', but the new value is reduced to weak L head normal form before being placed into the map, whether it is the given . value or a result of the combining function. 6 O(min(m,s))9. Removes the key from the map along with its associated E value. If the key is not a member of the map, the map is unchanged. 7 O(min(m,s)):. Adjusts the value at the given key by calling the given N function on it. If the key is not a member of the map, the map is unchanged. 8 O(min(m,s)). Like 7(, but the function is applied strictly. 9 O(min(m,s))3. Updates the value at the given key: if the given  function returns 93, the value and its associated key are removed; if  : a- is returned, the old value is replaced with a. If the key is 0 not a member of the map, the map is unchanged. : O(min(m,s)). Like 9, but also returns : the original value,  or 9( if the key is not a member of the map. ; O(min(m,s)):. The most general modification function, allowing you to N modify the value at the given key, whether or not it is a member of the map. ( In short: the given function is passed : the value at the key if it is  present, or 9$ otherwise; if the function returns : a value, the N new value is inserted into the map, otherwise the old value is removed. More  precisely, for  alter f k m: If k is a member of m, f (: oldValue) is called. Now:  If f returned : newValue, oldValue is replaced with newValue.  If f returned 9, k and oldValue are removed from the map.  If, instead, k is not a member of m, f 9 is called, and:  If f returned : value, value is inserted into the map, at k.  If f returned 9, the map is unchanged. IThe function is applied lazily only if the given key is a prefix of more  than one key in the map. < O(min(m,s)). Like ;/, but the function is always applied strictly. =O(1). ; iff the map is empty. >O(n m)C. The number of elements in the map. The value is built up lazily, L allowing for delivery of partial results without traversing the whole map. ?O(n m)B. The number of elements in the map. The value is built strictly: > no value is returned until the map has been fully traversed. @ O(min(m,s)). ;5 iff the given key is associated with a value in the  map. A O(min(m,s)). <5 iff the given key is associated with a value in the  map. B O(min(m,s)). :5 the value in the map associated with the given key,  or 9( if the key is not a member of the map. C O(min(m,s)). Like B., but returns the given value when the key is  not a member of the map. DO(min(n1 m1,n2 m2)). ;. iff the first map is a submap of the second, I i.e. all keys that are members of the first map are also members of the 7 second map, and their associated values are the same.  isSubmapOf = isSubmapOfBy (==) EO(min(n1 m1,n2 m2)). Like D#, but one can specify the equality ! relation applied to the values. ;D iff all keys that are members of the first map are also members of ( the second map, and the given function f returns ; for all f  firstMapValue secondMapValue where  firstMapValue and secondMapValue are  associated with the same key. FO(min(n1 m1,n2 m2)). ;- iff the first map is a proper submap of the M second, i.e. all keys that are members of the first map are also members of L the second map, and their associated values are the same, but the maps are M not equal. That is, at least one key was a member of the second map but not  the first. , isProperSubmapOf = isProperSubmapOfBy (==) GO(min(n1 m1,n2 m2)). Like F, but one can specify the * equality relation applied to the values. ;D iff all keys that are members of the first map are also members of ( the second map, and the given function f returns ; for all f  firstMapValue secondMapValue where  firstMapValue and secondMapValue are M associated with the same key, and at least one key in the second map is not  a member of the first. HO(min(n1 m1,n2 m2))4. The union of the two maps: the map which contains N all keys that are members of either map. This union is left-biased: if a key C is a member of both maps, the value from the first map is chosen. CThe worst-case performance occurs when the two maps are identical.  union = unionWith const IO(min(n1 m1,n2 m2)). Like H, but the combining function (=)  is applied strictly.  union' = unionWith' const JO(min(n1 m1,n2 m2)). Like H$, but the given function is used to H determine the new value if a key is a member of both given maps. For a  function f, the new value is f firstMapValue secondMapValue. KO(min(n1 m1,n2 m2)). Like J , but the combining function is  applied strictly. LO(min(n1 m1,n2 m2)). Like J, but in addition to the two 6 values, the key is passed to the combining function. MO(min(n1 m1,n2 m2)). Like L , but the combining function is  applied strictly. N O(sum(n))=. The union of all the maps: the map which contains all keys M that are members of any of the maps. If a key is a member of multiple maps, N the value that occurs in the earliest of the maps (according to the order of  the given list) is chosen. CThe worst-case performance occurs when all the maps are identical.  unions = unionsWith const O O(sum(n)). Like N, but the combining function (=) is  applied strictly.  unions' = unionsWith' const P O(sum(n)). Like N., but the given function determines the final M value if a key is a member of more than one map. The function is applied as . a left fold over the values in the given list's order. For example: K unionsWith (-) [fromList [("a",1)],fromList [("a",2)],fromList [("a",3)]]  == fromList [("a",(1-2)-3)]  == fromList [("a",-4)] Q O(sum(n)). Like P(, but the combining function is applied  strictly. R O(sum(n)). Like P*, but in addition to the two values under = consideration, the key is passed to the combining function. S O(sum(n)). Like R(, but the combining function is applied  strictly. TO(min(n1 m1,n2 m2))0. The difference of the two maps: the map which L contains all keys that are members of the first map and not of the second. CThe worst-case performance occurs when the two maps are identical. / difference = differenceWith (\_ _ -> Nothing) UO(min(n1 m1,n2 m2)). Like T, but the given function L determines what to do when a key is a member of both maps. If the function  returns 9$, the key is removed; if it returns : a new value, 3 that value replaces the old one in the first map. VO(min(n1 m1,n2 m2)). Like U, but in addition to the two E values, the key they are associated with is passed to the combining  function. WO(min(n1 m1,n2 m2))2. The intersection of the two maps: the map which 2 contains all keys that are members of both maps. CThe worst-case performance occurs when the two maps are identical. ' intersection = intersectionWith const XO(min(n1 m1,n2 m2)). Like W , but the combining function is  applied strictly. ) intersection' = intersectionWith' const YO(min(n1 m1,n2 m2)). Like W, but the given function  determines the new values. ZO(min(n1 m1,n2 m2)). Like Y, but the combining function  is applied strictly. [O(min(n1 m1,n2 m2)). Like Y, but in addition to the two E values, the key they are associated with is passed to the combining  function. \O(min(n1 m1,n2 m2)). Like [, but the combining  function is applied strictly. ]O(n m)B. Apply the given function to the elements in the map, discarding & those for which the function returns <. ^O(n m). Like ]2, but the key associated with the element is also  passed to the given predicate. _O(n m)>. A pair of maps: the first element contains those values for # which the given predicate returns ;$, and the second contains those for  which it was <. `O(n m). Like _-, but the key associated with the element is % also passed to the given predicate. aO(n m)B. Apply the given function to the elements in the map, preserving  only the : results. bO(n m). Like a2, but the key associated with the element is also  passed to the given function. cO(n m)B. Apply the given function to the elements in the map, separating  the > results from the ?). The first element of the pair contains 0 the former results, and the second the latter. dO(n m). Like c-, but the key associated with the element is $ also passed to the given function. eO(n m);. Apply the given function to all the elements in the map. fO(n m). Like e#, but apply the function strictly. gO(n m). Like e7, but also pass the key associated with the element to  the given function. hO(n m). Like g#, but apply the function strictly. iO(n m)5. Apply the given function to all the keys in a map.  mapKeys = mapKeysWith const jO(n m). Like i., but use the first given function to combine @ elements if the second function gives two keys the same value. kO(n m)B. Apply the given function to the contents of all the keys in the  map. ! mapInKeys = mapInKeysWith const lO(n m). Like k', but combine identical keys strictly. # mapInKeys' = mapInKeysWith' const mO(n m). Like k., but use the first given function to combine @ elements if the second function gives two keys the same value. nO(n m). Like m-, but apply the combining function strictly. oO(n m). Like  Data.List. mapAccumL on the  representation. Essentially a combination of e and  : the given N function is applied to each element of the map, resulting in a new value for 8 the accumulator and a replacement element for the map. pO(n m). Like o(, but the function is applied strictly. qO(n m). Like o0, but the function receives the key in addition " to the value associated with it. rO(n m). Like q(, but the function is applied strictly. sO(n m). Like o1, but in ascending order, as though operating on  the  representation. tO(n m). Like s(, but the function is applied strictly. uO(n m). Like s', but the function receives the key in + addition to the value associated with it. vO(n m). Like u(, but the function is applied strictly. wO(n m). Like o2, but in descending order, as though operating on  the  representation. xO(n m). Like w(, but the function is applied strictly. yO(n m). Like w', but the function receives the key in + addition to the value associated with it. zO(n m). Like y, but the function is applied  strictly. {O(n m). Equivalent to a list foldr on the  representation, ! folding only over the elements. |O(n m). Equivalent to a list foldr on the  representation, . folding over both the keys and the elements. }O(n m). Equivalent to a list foldr on the  representation. ~O(n m). Equivalent to a list foldr on the  representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldr on the  representation. O(n m). Equivalent to a list foldr on the  representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl on the toList representation. O(n m). Equivalent to a list foldl on the toList representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl" on the toAscList representation. O(n m). Equivalent to a list foldl" on the toAscList representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl# on the toDescList representation. O(n m). Equivalent to a list foldl# on the toDescList representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl' on the  representation. O(n m). Equivalent to a list foldl' on the  representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl' on the  representation. O(n m). Equivalent to a list foldl' on the  representation, . folding over both the keys and the elements. O(n m). Equivalent to a list foldl' on the   representation. O(n m). Equivalent to a list foldl' on the  > representation, folding over both the keys and the elements. O(n m)>. Converts the map to a list of the key-value pairs contained  within, in undefined order. O(n m)>. Converts the map to a list of the key-value pairs contained  within, in ascending order. O(n m)>. Converts the map to a list of the key-value pairs contained  within, in descending order. O(n m)@. Creates a map from a list of key-value pairs. If a key occurs D more than once, the value from the last pair (according to the list' s order) & is the one which ends up in the map.  fromList = fromListWith const O(n m). Like 2, but the given function is used to determine the H final value if a key occurs more than once. The function is applied as K though it were flipped and then applied as a left fold over the values in  the given list';s order. Or, equivalently (except as far as performance is J concerned), as though the function were applied as a right fold over the ( values in the reverse of the given list's order. For example: 4 fromListWith (-) [("a",1),("a",2),("a",3),("a",4)] $ == fromList [("a",4-(3-(2-1)))]  == fromList [("a",2)] O(n m). Like (, but the combining function is applied  strictly. O(n m). Like ,, but the key, in addition to the values to 3 be combined, is passed to the combining function. O(n m). Like (, but the combining function is applied  strictly. O(m)A. Removes and returns the minimal key in the map, along with the 0 value associated with it. If the map is empty, 9 and the original  map are returned. O(m)A. Removes and returns the maximal key in the map, along with the 0 value associated with it. If the map is empty, 9 and the original  map are returned. O(m). Like @ composed with . : the minimal key in the " map and its associated value, or 9 if the map is empty. O(m). Like @ composed with . : the minimal key in the " map and its associated value, or 9 if the map is empty. O(m). Like A composed with . The map without its minimal 5 key, or the unchanged original map if it was empty. O(m). Like A composed with . The map without its maximal 5 key, or the unchanged original map if it was empty.  O(min(m,s))7. Splits the map in two about the given key. The first L element of the resulting pair is a map containing the keys lesser than the = given key; the second contains those keys that are greater.  O(min(m,s)). Like -, but also returns the value associated with  the given key, if any. O(m). :; the key of the map which precedes the given key in order, % along with its associated value, or 9 if the map is empty. O(m). :; the key of the map which succeeds the given key in order, % along with its associated value, or 9 if the map is empty. O(s)>. The map which contains all keys of which the given key is a  prefix. For example: D lookupPrefix "ab" (fromList [("a",1),("ab",2),("ac",3),("abc",4)]) % == fromList [("ab",2),("abc",4)] O(s)B. Prepends the given key to all the keys of the map. For example: - addPrefix "xa" (fromList [("a",1),("b",2)]) & == fromList [("xaa",1),("xab",2)] O(s)>. The map which contains all keys of which the given key is a J prefix, with the prefix removed from each key. If the given key is not a F prefix of any key in the map, an empty map is returned. For example:  9 deletePrefix "a" (fromList [("a",1),("ab",2),("ac",3)]) ) == fromList [("",1),("b",2),("c",3)] JThis function can be used, for instance, to reduce potentially expensive I/O N operations: if you need to find the value in a map associated with a string, J but you only have a prefix of it and retrieving the rest is an expensive  operation, calling ' with what you have might allow you to N avoid the operation: if the resulting map is empty, the entire string cannot  be a member of the map. O(s)E. Deletes all keys which are suffixes of the given key. For example: F deleteSuffixes "ab" (fromList $ zip ["a","ab","ac","b","abc"] [1..]) + == fromList [("a",1),("ac",3),("b",4)] O(1)C. A triple containing the longest common prefix of all keys in the K map, the value associated with that prefix, if any, and the map with that G prefix removed from all the keys as well as the map itself. Examples: * splitPrefix (fromList [("a",1),("b",2)]) 1 == ("", Nothing, fromList [("a",1),("b",2)]) 4 splitPrefix (fromList [("a",1),("ab",2),("ac",3)]) 1 == ("a", Just 1, fromList [("b",2),("c",3)]) O(1)A. The children of the longest common prefix in the trie as maps, J associated with their distinguishing key value. If the map contains less B than two keys, this function will return an empty map. Examples; 4 children (fromList [("a",1),("abc",2),("abcd",3)]) 8 == Map.fromList [('b',fromList [("c",2),("cd",3)])] ' children (fromList [("b",1),("c",2)]) F == Map.fromList [('b',fromList [("",1)]),('c',fromList [("",2)])] O(1)D. The children of the first element of the longest common prefix in N the trie as maps, associated with their distinguishing key value. If the map F contains less than two keys, this function will return an empty map. MIf the longest common prefix of all keys in the trie is the empty list, this  function is equivalent to .  Examples: - children1 (fromList [("abc",1),("abcd",2)]) : == Map.fromList [('a',fromList [("bc",1),("bcd",2)])] ( children1 (fromList [("b",1),("c",2)]) F == Map.fromList [('b',fromList [("",1)]),('c',fromList [("",2)])] O(n m). Displays the map'/s internal structure in an undefined way. That 4 is to say, no program should depend on the function' s results. O(n m). Like -, but uses the given function to display the ' elements of the map. Still undefined. B/C0123456789:;<=>?@ABCDEFGDHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefEghFijklmnopqrstuvwxyzGH{|}~IJKLMNOPQRy/0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~y/01234569:78;<=>?@ABCDEFGHINOJLPRKMQSTUVWXY[Z\]^_`abcdefghijklmnoqprsutvwyxz{|}~B/C0123456789:;<=>?@ABCDEFGDHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefEghFijklmnopqrstuvwxyzGH{|}~IJKLMNOPQR Safe-Inferredy0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferredy0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferredy0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred31The data structure itself: a set of keys of type [a] implemented as a  trie, using map to map keys of type a to sub-tries. Regarding the instances:  The CMap" type is internal, ignore it. For  and 4 an  1 instance is required: what this means is that map a v is expected to be  an instance of , given  v.  The  constraint for the 4& instance is misleading: it is needed  only because  is a superclass of 4.  The 6 instance defines 7 as  and 8 as  . O(1). The empty set. O(1)3. The singleton set containing only the given key.  O(min(m,s))8. Inserts the key into the set. If the key is already a * member of the set, the set is unchanged.  O(min(m,s))>. Removes the key from the set. If the key is not a member of  the set, the set is unchanged. O(1). ; iff the set is empty. O(n m)?. The number of keys in the set. The value is built up lazily, L allowing for delivery of partial results without traversing the whole set. O(n m)A. The number of keys in the set. The value is built strictly: no ; value is returned until the set has been fully traversed.  O(min(m,s)). ;0 iff the given key is contained within the set.  O(min(m,s)). <0 iff the given key is contained within the set. O(min(n1 m1,n2 m2)). ;. iff the first set is a subset of the second, I i.e. all keys that are members of the first set are also members of the  second set. O(min(n1 m1,n2 m2)). ;- iff the first set is a proper subset of the H second, i.e. the first is a subset of the second, but the sets are not  equal. O(min(n1 m1,n2 m2))4. The union of the two sets: the set which contains * all keys that are members of either set. CThe worst-case performance occurs when the two sets are identical.  O(sum(n))=. The union of all the sets: the set which contains all keys & that are members of any of the sets. CThe worst-case performance occurs when all the sets are identical. O(min(n1 m1,n2 m2))0. The difference of the two sets: the set which L contains all keys that are members of the first set and not members of the  second set. CThe worst-case performance occurs when the two sets are identical. O(min(n1 m1,n2 m2))2. The intersection of the two sets: the set which 2 contains all keys that are members of both sets. CThe worst-case performance occurs when the two sets are identical. O(n m)A. The set of those keys in the set for which the given predicate  returns ;. O(n m)B. A pair of sets: the first element contains those keys for which  the given predicate returns ;(, and the second element contains those  for which it was <. O(n m)7. Apply the given function to all the keys in the set. O(n m)B. Apply the given function to the contents of all the keys in the  set. O(n m). Equivalent to a list foldr on the  representation. O(n m). Equivalent to a list foldr on the  representation. O(n m). Equivalent to a list foldr on the  representation. O(n m). Equivalent to a list foldl on the  representation. O(n m). Equivalent to a list foldl on the  representation. O(n m). Equivalent to a list foldl on the  representation. O(n m). Equivalent to a list foldl' on the  representation. O(n m). Equivalent to a list foldl' on the  representation. O(n m). Equivalent to a list foldl' on the   representation. O(n m)>. Converts the set to a list of the keys contained within, in  undefined order. O(n m)>. Converts the set to a list of the keys contained within, in  ascending order. O(n m)>. Converts the set to a list of the keys contained within, in  descending order. O(n m)%. Creates a set from a list of keys. O(m)@. Removes and returns the minimal key in the set. If the set is  empty, 9$ and the original set are returned. O(m)@. Removes and returns the maximal key in the set. If the set is  empty, 9$ and the original set are returned. O(m). Like @ composed with . : the minimal key in the  set, or 9 if the set is empty. O(m). Like @ composed with . : the maximal key in the  set, or 9 if the set is empty. O(m). Like A composed with . The set without its minimal 5 key, or the unchanged original set if it was empty. O(m). Like A composed with . The set without its maximal 5 key, or the unchanged original set if it was empty.  O(min(m,s))7. Splits the set in two about the given key. The first L element of the resulting pair is a set containing the keys lesser than the = given key; the second contains those keys that are greater.  O(min(m,s)). Like /, but also returns whether the given key was a  member of the set or not. O(m). :; the key of the set which precedes the given key in order,  or 9 if the set is empty. O(m). :; the key of the set which succeeds the given key in order,  or 9 if the set is empty. O(s)>. The set which contains all keys of which the given key is a  prefix. For example: 4 lookupPrefix "ab" (fromList ["a","ab","ac","abc"])  == fromList ["ab","abc"] O(s)B. Prepends the given key to all the keys of the set. For example: B addPrefix "pre" (fromList ["a","b"]) == fromList ["prea","preb"] O(s)>. The set which contains all keys of which the given key is a J prefix, with the prefix removed from each key. If the given key is not a F prefix of any key in the set, an empty set is returned. For example:  F deletePrefix "a" (fromList ["a","ab","ac"]) == fromList ["","b","c"] JThis function can be used, for instance, to reduce potentially expensive I/O M operations: if you need to check whether a string is a member of a set, but F you only have a prefix of it and retrieving the rest is an expensive  operation, calling ' with what you have might allow you to N avoid the operation: if the resulting set is empty, the entire string cannot  be a member of the set. O(s)E. Deletes all keys which are suffixes of the given key. For example: F deleteSuffixes "ab" (fromList $ zip ["a","ab","ac","b","abc"] [1..]) + == fromList [("a",1),("ac",3),("b",4)] O(1)C. A triple containing the longest common prefix of all keys in the I set, whether that prefix was a member of the set, and the set with that G prefix removed from all the keys as well as the set itself. Examples: E splitPrefix (fromList ["a","b"]) == ("", False, fromList ["a","b"]) K splitPrefix (fromList ["a","ab","ac"]) == ("a", True, fromList ["b","c"]) O(1)A. The children of the longest common prefix in the trie as sets, J associated with their distinguishing key value. If the set contains less B than two keys, this function will return an empty map. Examples; ( children (fromList ["a","abc","abcd"]) 0 == Map.fromList [('b',fromList ["c","cd"])]  children (fromList ["b","c"]) > == Map.fromList [('b',fromList [""]),('c',fromList [""])] O(1)D. The children of the first element of the longest common prefix in N the trie as sets, associated with their distinguishing key value. If the set F contains less than two keys, this function will return an empty map. MIf the longest common prefix of all keys in the trie is the empty list, this  function is equivalent to .  Examples: % children1 (fromList ["abc","abcd"]) 2 == Map.fromList [('a',fromList ["bc","bcd"])]  children1 (fromList ["b","c"]) > == Map.fromList [('b',fromList [""]),('c',fromList [""])] O(n m). Displays the set'/s internal structure in an undefined way. That 4 is to say, no program should depend on the function' s results. DSTUVWXYZ[\]^_`abc33ASTUVWXYZ[\]^_`abc Safe-Inferred3 Safe-Inferred3  Safe-Inferred3 Safe-Inferredbdefghijklmnopqrstuvwxyz{|}~Nefgpqrstuwxy{|}`defghijklmnopqrstuvwxyz{|}~  Safe-Inferredy3The data structure itself: a map from keys of type [k] to values of type  v implemented as a trie, using map to map keys of type k to sub-tries. Regarding the instances:  The Trie class is internal, ignore it.  The  constraint for the 4& instance is misleading: it is needed  only because  is a superclass of 4.  The Foldable and 5" instances allow folding over and - traversing only the values, not the keys.  The 6 instance defines 7 as  and 8 as  . O(1). The empty map. O(s)>. The singleton map containing only the given key-value pair.  O(min(m,s))9. Inserts the key-value pair into the map. If the key is D already a member of the map, the given value replaces the old one.  O(min(m,s))9. Inserts the key-value pair into the map. If the key is D already a member of the map, the given value replaces the old one.  O(min(m,s))9. Inserts the key-value pair into the map. If the key is ; already a member of the map, the old value is replaced by  f givenValue  oldValue where f is the given function.  O(min(m,s)). Like ', but the new value is reduced to weak L head normal form before being placed into the map, whether it is the given . value or a result of the combining function.  O(min(m,s))9. Removes the key from the map along with its associated E value. If the key is not a member of the map, the map is unchanged.  O(min(m,s)):. Adjusts the value at the given key by calling the given N function on it. If the key is not a member of the map, the map is unchanged.  O(min(m,s)). Like (, but the function is applied strictly.  O(min(m,s))3. Updates the value at the given key: if the given  function returns 93, the value and its associated key are removed; if  : a- is returned, the old value is replaced with a. If the key is 0 not a member of the map, the map is unchanged.  O(min(m,s)). Like , but also returns : the original value,  or 9( if the key is not a member of the map.  O(min(m,s)):. The most general modification function, allowing you to N modify the value at the given key, whether or not it is a member of the map. ( In short: the given function is passed : the value at the key if it is  present, or 9$ otherwise; if the function returns : a value, the N new value is inserted into the map, otherwise the old value is removed. More  precisely, for  alter f k m: If k is a member of m, f (: oldValue) is called. Now:  If f returned : newValue, oldValue is replaced with newValue.  If f returned 9, k and oldValue are removed from the map.  If, instead, k is not a member of m, f 9 is called, and:  If f returned : value, value is inserted into the map, at k.  If f returned 9, the map is unchanged. LThe function is applied lazily only if the given key is a prefix of another  key in the map.  O(min(m,s)). Like /, but the function is always applied strictly. O(1). ; iff the map is empty. O(n m)C. The number of elements in the map. The value is built up lazily, L allowing for delivery of partial results without traversing the whole map. O(n m)B. The number of elements in the map. The value is built strictly: > no value is returned until the map has been fully traversed.  O(min(m,s)). ;5 iff the given key is associated with a value in the  map.  O(min(m,s)). <5 iff the given key is associated with a value in the  map.  O(min(m,s)). :5 the value in the map associated with the given key,  or 9( if the key is not a member of the map.  O(min(m,s)). Like ., but returns the given value when the key is  not a member of the map. O(min(n1 m1,n2 m2)). ;. iff the first map is a submap of the second, I i.e. all keys that are members of the first map are also members of the 7 second map, and their associated values are the same.  isSubmapOf = isSubmapOfBy (==) O(min(n1 m1,n2 m2)). Like #, but one can specify the equality ! relation applied to the values. ;D iff all keys that are members of the first map are also members of ( the second map, and the given function f returns ; for all f  firstMapValue secondMapValue where  firstMapValue and secondMapValue are  associated with the same key. O(min(n1 m1,n2 m2)). ;- iff the first map is a proper submap of the M second, i.e. all keys that are members of the first map are also members of L the second map, and their associated values are the same, but the maps are M not equal. That is, at least one key was a member of the second map but not  the first. , isProperSubmapOf = isProperSubmapOfBy (==) O(min(n1 m1,n2 m2)). Like , but one can specify the * equality relation applied to the values. ;D iff all keys that are members of the first map are also members of ( the second map, and the given function f returns ; for all f  firstMapValue secondMapValue where  firstMapValue and secondMapValue are M associated with the same key, and at least one key in the second map is not  a member of the first. O(min(n1 m1,n2 m2))4. The union of the two maps: the map which contains N all keys that are members of either map. This union is left-biased: if a key C is a member of both maps, the value from the first map is chosen. CThe worst-case performance occurs when the two maps are identical.  union = unionWith const O(min(n1 m1,n2 m2)). Like , but the combining function (=) is  applied strictly.  union' = unionWith' const O(min(n1 m1,n2 m2)). Like $, but the given function is used to H determine the new value if a key is a member of both given maps. For a  function f, the new value is f firstMapValue secondMapValue. O(min(n1 m1,n2 m2)). Like  , but the combining function is  applied strictly. O(min(n1 m1,n2 m2)). Like , but in addition to the two 6 values, the key is passed to the combining function. O(min(n1 m1,n2 m2)). Like  , but the combining function is  applied strictly.  O(sum(n))=. The union of all the maps: the map which contains all keys M that are members of any of the maps. If a key is a member of multiple maps, N the value that occurs in the earliest of the maps (according to the order of  the given list) is chosen. CThe worst-case performance occurs when all the maps are identical.  unions = unionsWith const  O(sum(n)). Like , but the combining function (=) is  applied strictly.  unions' = unionsWith' const  O(sum(n)). Like ., but the given function determines the final M value if a key is a member of more than one map. The function is applied as . a left fold over the values in the given list's order. For example: K unionsWith (-) [fromList [("a",1)],fromList [("a",2)],fromList [("a",3)]]  == fromList [("a",(1-2)-3)]  == fromList [("a",-4)]  O(sum(n)). Like (, but the combining function is applied  strictly.  O(sum(n)). Like *, but in addition to the two values under = consideration, the key is passed to the combining function.  O(sum(n)). Like (, but the combining function is applied  strictly. O(min(n1 m1,n2 m2))0. The difference of the two maps: the map which L contains all keys that are members of the first map and not of the second. CThe worst-case performance occurs when the two maps are identical. / difference = differenceWith (\_ _ -> Nothing) O(min(n1 m1,n2 m2)). Like , but the given function L determines what to do when a key is a member of both maps. If the function  returns 9$, the key is removed; if it returns : a new value, 3 that value replaces the old one in the first map. O(min(n1 m1,n2 m2)). Like , but in addition to the two E values, the key they are associated with is passed to the combining  function.  O(min(n1 m1,n2 m2))2. The intersection of the two maps: the map which 2 contains all keys that are members of both maps. CThe worst-case performance occurs when the two maps are identical. ' intersection = intersectionWith const  O(min(n1 m1,n2 m2)). Like   , but the combining function is  applied strictly. ) intersection' = intersectionWith' const  O(min(n1 m1,n2 m2)). Like  , but the given function  determines the new values.  O(min(n1 m1,n2 m2)). Like  , but the combining function  is applied strictly.  O(min(n1 m1,n2 m2)). Like  , but in addition to the two E values, the key they are associated with is passed to the combining  function. O(min(n1 m1,n2 m2)). Like  , but the combining  function is applied strictly. O(n m)B. Apply the given function to the elements in the map, discarding & those for which the function returns <. O(n m). Like 2, but the key associated with the element is also  passed to the given predicate. O(n m)>. A pair of maps: the first element contains those values for # which the given predicate returns ;$, and the second contains those for  which it was <. O(n m). Like -, but the key associated with the element is % also passed to the given predicate. O(n m)B. Apply the given function to the elements in the map, preserving  only the : results. O(n m). Like 2, but the key associated with the element is also  passed to the given function. O(n m)B. Apply the given function to the elements in the map, separating  the > results from the ?). The first element of the pair contains 0 the former results, and the second the latter. O(n m). Like -, but the key associated with the element is $ also passed to the given function. O(n m);. Apply the given function to all the elements in the map. O(n m). Like #, but apply the function strictly. O(n m). Like 7, but also pass the key associated with the element to  the given function. O(n m). Like #, but apply the function strictly. O(n m)5. Apply the given function to all the keys in a map.  mapKeys = mapKeysWith const O(n m). Like ., but use the first given function to combine @ elements if the second function gives two keys the same value. O(n m)B. Apply the given function to the contents of all the keys in the  map. ! mapInKeys = mapInKeysWith const O(n m). Like ', but combine identical keys strictly. # mapInKeys' = mapInKeysWith' const O(n m). Like ., but use the first given function to combine @ elements if the second function gives two keys the same value.  O(n m). Like -, but apply the combining function strictly. !O(n m). Like  Data.List. mapAccumL on the ? representation. Essentially a combination of  and 3 : the given N function is applied to each element of the map, resulting in a new value for 8 the accumulator and a replacement element for the map. "O(n m). Like !(, but the function is applied strictly. #O(n m). Like !0, but the function receives the key in addition " to the value associated with it. $O(n m). Like #(, but the function is applied strictly. %O(n m). Like !1, but in ascending order, as though operating on  the @ representation. &O(n m). Like %(, but the function is applied strictly. 'O(n m). Like %', but the function receives the key in + addition to the value associated with it. (O(n m). Like '(, but the function is applied strictly. )O(n m). Like !2, but in descending order, as though operating on  the A representation. *O(n m). Like )(, but the function is applied strictly. +O(n m). Like )', but the function receives the key in + addition to the value associated with it. ,O(n m). Like +, but the function is applied  strictly. -O(n m). Equivalent to a list foldr on the ? representation, ! folding only over the elements. .O(n m). Equivalent to a list foldr on the ? representation, . folding over both the keys and the elements. /O(n m). Equivalent to a list foldr on the @ representation. 0O(n m). Equivalent to a list foldr on the @ representation, . folding over both the keys and the elements. 1O(n m). Equivalent to a list foldr on the A representation. 2O(n m). Equivalent to a list foldr on the A representation, . folding over both the keys and the elements. 3O(n m). Equivalent to a list foldl on the toList representation. 4O(n m). Equivalent to a list foldl on the toList representation, . folding over both the keys and the elements. 5O(n m). Equivalent to a list foldl" on the toAscList representation. 6O(n m). Equivalent to a list foldl" on the toAscList representation, . folding over both the keys and the elements. 7O(n m). Equivalent to a list foldl# on the toDescList representation. 8O(n m). Equivalent to a list foldl# on the toDescList representation, . folding over both the keys and the elements. 9O(n m). Equivalent to a list foldl' on the ? representation. :O(n m). Equivalent to a list foldl' on the ? representation, . folding over both the keys and the elements. ;O(n m). Equivalent to a list foldl' on the @ representation. <O(n m). Equivalent to a list foldl' on the @ representation, . folding over both the keys and the elements. =O(n m). Equivalent to a list foldl' on the A  representation. >O(n m). Equivalent to a list foldl' on the A > representation, folding over both the keys and the elements. ?O(n m)>. Converts the map to a list of the key-value pairs contained  within, in undefined order. @O(n m)>. Converts the map to a list of the key-value pairs contained  within, in ascending order. AO(n m)>. Converts the map to a list of the key-value pairs contained  within, in descending order. BO(n m)@. Creates a map from a list of key-value pairs. If a key occurs D more than once, the value from the last pair (according to the list' s order) & is the one which ends up in the map.  fromList = fromListWith const CO(n m). Like B2, but the given function is used to determine the H final value if a key occurs more than once. The function is applied as K though it were flipped and then applied as a left fold over the values in  the given list';s order. Or, equivalently (except as far as performance is J concerned), as though the function were applied as a right fold over the ( values in the reverse of the given list's order. For example: 4 fromListWith (-) [("a",1),("a",2),("a",3),("a",4)] $ == fromList [("a",4-(3-(2-1)))]  == fromList [("a",2)] DO(n m). Like C(, but the combining function is applied  strictly. EO(n m). Like C,, but the key, in addition to the values to 3 be combined, is passed to the combining function. FO(n m). Like E(, but the combining function is applied  strictly. GO(m)A. Removes and returns the minimal key in the map, along with the 0 value associated with it. If the map is empty, 9 and the original  map are returned. HO(m)A. Removes and returns the maximal key in the map, along with the 0 value associated with it. If the map is empty, 9 and the original  map are returned. IO(m). Like @ composed with G. : the minimal key in the " map and its associated value, or 9 if the map is empty. JO(m). Like @ composed with H. : the minimal key in the " map and its associated value, or 9 if the map is empty. KO(m). Like A composed with G. The map without its minimal 5 key, or the unchanged original map if it was empty. LO(m). Like A composed with H. The map without its maximal 5 key, or the unchanged original map if it was empty. M O(min(m,s))7. Splits the map in two about the given key. The first L element of the resulting pair is a map containing the keys lesser than the = given key; the second contains those keys that are greater. N O(min(m,s)). Like M-, but also returns the value associated with  the given key, if any. OO(m). :; the key of the map which precedes the given key in order, % along with its associated value, or 9 if the map is empty. PO(m). :; the key of the map which succeeds the given key in order, % along with its associated value, or 9 if the map is empty. QO(s)>. The map which contains all keys of which the given key is a  prefix. For example: D lookupPrefix "ab" (fromList [("a",1),("ab",2),("ac",3),("abc",4)]) % == fromList [("ab",2),("abc",4)] RO(s)B. Prepends the given key to all the keys of the map. For example: - addPrefix "xa" (fromList [("a",1),("b",2)]) & == fromList [("xaa",1),("xab",2)] SO(s)>. The map which contains all keys of which the given key is a J prefix, with the prefix removed from each key. If the given key is not a F prefix of any key in the map, an empty map is returned. For example:  9 deletePrefix "a" (fromList [("a",1),("ab",2),("ac",3)]) ) == fromList [("",1),("b",2),("c",3)] JThis function can be used, for instance, to reduce potentially expensive I/O N operations: if you need to find the value in a map associated with a string, J but you only have a prefix of it and retrieving the rest is an expensive  operation, calling S' with what you have might allow you to N avoid the operation: if the resulting map is empty, the entire string cannot  be a member of the map. TO(s)E. Deletes all keys which are suffixes of the given key. For example: F deleteSuffixes "ab" (fromList $ zip ["a","ab","ac","b","abc"] [1..]) + == fromList [("a",1),("ac",3),("b",4)] UO(m)C. A triple containing the longest common prefix of all keys in the K map, the value associated with that prefix, if any, and the map with that G prefix removed from all the keys as well as the map itself. Examples: * splitPrefix (fromList [("a",1),("b",2)]) 1 == ("", Nothing, fromList [("a",1),("b",2)]) 4 splitPrefix (fromList [("a",1),("ab",2),("ac",3)]) 1 == ("a", Just 1, fromList [("b",2),("c",3)]) VO(m)A. The children of the longest common prefix in the trie as maps, J associated with their distinguishing key value. If the map contains less B than two keys, this function will return an empty map. Examples; 4 children (fromList [("a",1),("abc",2),("abcd",3)]) 8 == Map.fromList [('b',fromList [("c",2),("cd",3)])] ' children (fromList [("b",1),("c",2)]) F == Map.fromList [('b',fromList [("",1)]),('c',fromList [("",2)])] WO(1)D. The children of the first element of the longest common prefix in N the trie as maps, associated with their distinguishing key value. If the map F contains less than two keys, this function will return an empty map. MIf the longest common prefix of all keys in the trie is the empty list, this  function is equivalent to V.  Examples: - children1 (fromList [("abc",1),("abcd",2)]) : == Map.fromList [('a',fromList [("bc",1),("bcd",2)])] ( children1 (fromList [("b",1),("c",2)]) F == Map.fromList [('b',fromList [("",1)]),('c',fromList [("",2)])] XO(n m). Displays the map'/s internal structure in an undefined way. That 4 is to say, no program should depend on the function' s results. YO(n m). Like X-, but uses the given function to display the ' elements of the map. Still undefined.       !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYy      !#"$%'&()+*,-./0123456789:;<=>?@ABCEDFGHIJKLMNOPQRSTUVWXY      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY  Safe-InferredZy      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZZZ  Safe-Inferred[y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY[[[  Safe-Inferred\y      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXY\\\ Safe-Inferred3]1The data structure itself: a set of keys of type [a] implemented as a  trie, using map to map keys of type a to sub-tries. Regarding the instances:  The CMap" type is internal, ignore it. For  and 4 an  1 instance is required: what this means is that map a v is expected to be  an instance of , given  v.  The  constraint for the 4& instance is misleading: it is needed  only because  is a superclass of 4.  The 6 instance defines 7 as i and 8 as  ^. ^O(1). The empty set. _O(s)3. The singleton set containing only the given key. ` O(min(m,s))8. Inserts the key into the set. If the key is already a * member of the set, the set is unchanged. a O(min(m,s))>. Removes the key from the set. If the key is not a member of  the set, the set is unchanged. bO(1). ; iff the set is empty. cO(n m)?. The number of keys in the set. The value is built up lazily, L allowing for delivery of partial results without traversing the whole set. dO(n m)A. The number of keys in the set. The value is built strictly: no ; value is returned until the set has been fully traversed. e O(min(m,s)). ;0 iff the given key is contained within the set. f O(min(m,s)). <0 iff the given key is contained within the set. gO(min(n1 m1,n2 m2)). ;. iff the first set is a subset of the second, I i.e. all keys that are members of the first set are also members of the  second set. hO(min(n1 m1,n2 m2)). ;- iff the first set is a proper subset of the H second, i.e. the first is a subset of the second, but the sets are not  equal. iO(min(n1 m1,n2 m2))4. The union of the two sets: the set which contains * all keys that are members of either set. CThe worst-case performance occurs when the two sets are identical. j O(sum(n))=. The union of all the sets: the set which contains all keys & that are members of any of the sets. CThe worst-case performance occurs when all the sets are identical. kO(min(n1 m1,n2 m2))0. The difference of the two sets: the set which L contains all keys that are members of the first set and not members of the  second set. CThe worst-case performance occurs when the two sets are identical. lO(min(n1 m1,n2 m2))2. The intersection of the two sets: the set which 2 contains all keys that are members of both sets. CThe worst-case performance occurs when the two sets are identical. mO(n m)A. The set of those keys in the set for which the given predicate  returns ;. nO(n m)B. A pair of sets: the first element contains those keys for which  the given predicate returns ;(, and the second element contains those  for which it was <. oO(n m)7. Apply the given function to all the keys in the set. pO(n m)B. Apply the given function to the contents of all the keys in the  set. qO(n m). Equivalent to a list foldr on the z representation. rO(n m). Equivalent to a list foldr on the { representation. sO(n m). Equivalent to a list foldr on the | representation. tO(n m). Equivalent to a list foldl on the z representation. uO(n m). Equivalent to a list foldl on the { representation. vO(n m). Equivalent to a list foldl on the | representation. wO(n m). Equivalent to a list foldl' on the z representation. xO(n m). Equivalent to a list foldl' on the { representation. yO(n m). Equivalent to a list foldl' on the |  representation. zO(n m)>. Converts the set to a list of the keys contained within, in  undefined order. {O(n m)>. Converts the set to a list of the keys contained within, in  ascending order. |O(n m)>. Converts the set to a list of the keys contained within, in  descending order. }O(n m)%. Creates a set from a list of keys. ~O(m)@. Removes and returns the minimal key in the set. If the set is  empty, 9$ and the original set are returned. O(m)@. Removes and returns the maximal key in the set. If the set is  empty, 9$ and the original set are returned. O(m). Like @ composed with ~. : the minimal key in the  set, or 9 if the set is empty. O(m). Like @ composed with . : the maximal key in the  set, or 9 if the set is empty. O(m). Like A composed with ~. The set without its minimal 5 key, or the unchanged original set if it was empty. O(m). Like A composed with . The set without its maximal 5 key, or the unchanged original set if it was empty.  O(min(m,s))7. Splits the set in two about the given key. The first L element of the resulting pair is a set containing the keys lesser than the = given key; the second contains those keys that are greater.  O(min(m,s)). Like /, but also returns whether the given key was a  member of the set or not. O(m). :; the key of the set which precedes the given key in order,  or 9 if the set is empty. O(m). :; the key of the set which succeeds the given key in order,  or 9 if the set is empty. O(s)>. The set which contains all keys of which the given key is a  prefix. For example: 4 lookupPrefix "ab" (fromList ["a","ab","ac","abc"])  == fromList ["ab","abc"] O(s)B. Prepends the given key to all the keys of the set. For example: B addPrefix "pre" (fromList ["a","b"]) == fromList ["prea","preb"] O(s)>. The set which contains all keys of which the given key is a J prefix, with the prefix removed from each key. If the given key is not a F prefix of any key in the set, an empty set is returned. For example:  F deletePrefix "a" (fromList ["a","ab","ac"]) == fromList ["","b","c"] JThis function can be used, for instance, to reduce potentially expensive I/O M operations: if you need to check whether a string is a member of a set, but F you only have a prefix of it and retrieving the rest is an expensive  operation, calling ' with what you have might allow you to N avoid the operation: if the resulting set is empty, the entire string cannot  be a member of the set. O(s)E. Deletes all keys which are suffixes of the given key. For example: F deleteSuffixes "ab" (fromList $ zip ["a","ab","ac","b","abc"] [1..]) + == fromList [("a",1),("ac",3),("b",4)] O(m)C. A triple containing the longest common prefix of all keys in the I set, whether that prefix was a member of the set, and the set with that G prefix removed from all the keys as well as the set itself. Examples: E splitPrefix (fromList ["a","b"]) == ("", False, fromList ["a","b"]) K splitPrefix (fromList ["a","ab","ac"]) == ("a", True, fromList ["b","c"]) O(m)A. The children of the longest common prefix in the trie as sets, J associated with their distinguishing key value. If the set contains less B than two keys, this function will return an empty map. Examples; ( children (fromList ["a","abc","abcd"]) 0 == Map.fromList [('b',fromList ["c","cd"])]  children (fromList ["b","c"]) > == Map.fromList [('b',fromList [""]),('c',fromList [""])] O(1)D. The children of the first element of the longest common prefix in N the trie as sets, associated with their distinguishing key value. If the set F contains less than two keys, this function will return an empty map. MIf the longest common prefix of all keys in the trie is the empty list, this  function is equivalent to .  Examples: % children1 (fromList ["abc","abcd"]) 2 == Map.fromList [('a',fromList ["bc","bcd"])]  children1 (fromList ["b","c"]) > == Map.fromList [('b',fromList [""]),('c',fromList [""])] O(n m). Displays the set'/s internal structure in an undefined way. That 4 is to say, no program should depend on the function' s results. D]^_`abcdefghijklmnopqrstuvwxyz{|}~3]^_`abcdefghijklmnopqrstuvwxyz{|}~3]^_`abcdefghijklmnopqrstuvwxyz{|}~A]^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred3^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred3^_`abcdefghijklmnopqrstuvwxyz{|}~ Safe-Inferred3^_`abcdefghijklmnopqrstuvwxyz{|}~ !"#$%&'()*+,-./0123456789:;<=>?@ABCDEF)*/G.H21I0J3K,LMNO-PQDRSTU4V7WXYZ[\]^58_`6a9b>cdefghi:j;klmnopq<r=s#t$u%v&wxyz{|}~?@A!"FFF)*/2,LMNOTX^_>d:xz|~?@!"  F ) * / G . H 2 1 I 0 J 3 K , L M N O - P Q D R S T U 4 V 7 W X Y Z [ \ ] ^ 5 8 _ ` 6 a 9 b > c d e f g h i : j ; k l m n o p q < r = s # t $ u % v & w x y z { | } ~  ?   @ A   ! " F F F)*/2,LMNOTX^_>d:xz|~?@!"^)*/G.H21IJ3K,LMNO-PDS4V7WZ[\]586a9bcempqy{}?@A!"       !"#$%&'()*+,-./)*/G.H21IJ3K,LMNO-PDS4V7WZ[\]586a9bcempqy{}?@A!"                  !"#$%&'()*+0list-tries-0.5.1Data.ListTrie.Base.MapData.ListTrie.Patricia.MapData.ListTrie.Patricia.Map.EqData.ListTrie.Patricia.Map.OrdData.ListTrie.Patricia.Map.EnumData.ListTrie.Patricia.SetData.ListTrie.Patricia.Set.EqData.ListTrie.Patricia.Set.OrdData.ListTrie.Patricia.Set.EnumData.ListTrie.MapData.ListTrie.Map.EqData.ListTrie.Map.OrdData.ListTrie.Map.EnumData.ListTrie.SetData.ListTrie.Set.EqData.ListTrie.Set.OrdData.ListTrie.Set.EnumData.ListTrie.Base.ClassesData.ListTrie.UtilData.ListTrie.Base.Map.InternalData.ListTrie.Patricia.BaseData.ListTrie.Base WrappedIntMapAListOrdMapordCmp toAscList toDescList splitLookupsplitminViewWithKeymaxViewWithKeyfindPredecessor findSuccessor mapAccumAscmapAccumAscWithKey mapAccumDescmapAccumDescWithKeyMapeqCmpempty singleton doubletonnulllookup insertWithinsertupdateadjustdeletealter unionWithdifferenceWithintersectionWith unionWithKeydifferenceWithKeyintersectionWithKeymap mapWithKeymapAccummapAccumWithKeyfiltertoListfromList fromListWithserializeToListdeserializeFromList isSubmapOfBy singletonViewTrieMapinsert' insertWith'adjust' updateLookupalter'sizesize'member notMemberlookupWithDefault isSubmapOfisProperSubmapOfisProperSubmapOfByunionunion' unionWith' unionWithKey'unionsunions' unionsWith unionsWith' unionsWithKeyunionsWithKey' difference intersection intersection'intersectionWith'intersectionWithKey' filterWithKey partitionpartitionWithKeymapMaybemapMaybeWithKey mapEithermapEitherWithKeymap' mapWithKey'mapKeys mapKeysWith mapInKeys mapInKeys' mapInKeysWithmapInKeysWith' mapAccum'mapAccumWithKey' mapAccumAsc'mapAccumAscWithKey' mapAccumDesc'mapAccumDescWithKey'foldr foldrWithKeyfoldrAscfoldrAscWithKey foldrDescfoldrDescWithKeyfoldl foldlWithKeyfoldlAscfoldlAscWithKey foldlDescfoldlDescWithKeyfoldl' foldlWithKey' foldlAsc'foldlAscWithKey' foldlDesc'foldlDescWithKey' fromListWith'fromListWithKeyfromListWithKey'minViewmaxViewfindMinfindMax deleteMin deleteMax lookupPrefix addPrefix deletePrefixdeleteSuffixes splitPrefixchildren children1showTrie showTrieWithTrieSet isSubsetOfisProperSubsetOfmapIn splitMemberAltaltEmpty<|> IntersectableintersectionValsintersectionVals'DifferentiabledifferenceVals Unionable unionVals unionVals'BoolabletoBool UnwrappableunwrapIdentityIdfmap'<$!>$fAltIdentityBool $fAltMaybea$fApplicativeIdentity$fFunctorIdentity#$fIntersectableIdentityBoolBoolBool $fDifferentiableIdentityBoolBool$fUnionableIdentityBool$fIntersectableMaybeabc$fDifferentiableMaybeab$fUnionableMaybea$fBoolableIdentity$fUnwrappableIdentity$fBoolableMaybe$fUnwrappableMaybe.:.:.bothghc-prim GHC.ClassesEqIMapALdeleteAndGetBydeleteByupdateFirstsBy$fOrdMapWrappedIntMapk$fMapWrappedIntMapk$fTraversableWrappedIntMap$fFoldableWrappedIntMap$fFunctorWrappedIntMap $fOrdMapMapk $fMapMapk$fOrdMapAListk $fMapAListk$fTraversableAList$fFoldableAList$fFunctorAList $fOrdAList $fEqAListPrefixOrdering DifferedAtPostFixSameCMapTriemkTrietPartshasValuenoValuetValtMapgenericInsertWith genericAdjust genericAltergenericUnionWithgenericUnionWithKeygenericIntersectionWithgenericIntersectionWithKeygenericMapInKeysWith genericToList minMaxView findMinMax safeMkTrieprependcomparePrefixeseqComparePrefixesordComparePrefixes tryCompressOrdbaseData.Traversable Traversable Data.MonoidMonoidmappendmempty Data.MaybeNothingJust GHC.TypesTrueFalseGHC.Baseconst Data.EitherLeftRight Data.TuplefstsndTr defaultUnion genericMapgenericMapWithKeygenericMapAccumgenericMapAccumWithKey$fBinaryTrieMap $fReadTrieMap $fShowTrieMap$fTraversableTrieMap$fFoldableTrieMap$fFunctorTrieMap$fMonoidTrieMap $fOrdTrieMap $fEqTrieMap$fTrieTrieMapMaybemapkTSunTS TrieSetBaseinTS$fBinaryTrieSet$fBinaryTrieSetBase $fReadTrieSet $fShowTrieSet$fMonoidTrieSet $fOrdTrieSet $fEqTrieSet$fOrdTrieSetBase$fEqTrieSetBase$fTrieTrieSetBaseIdentitymapkmapValmapMaponValsonMaps