h*f      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~0.2.0.1(c) Melanie Brown 2021-2024BSD3 (see the file LICENSE) brown.m@pm.meNone"%&(-1=deep-map1For use with indexed maps, folds, and traversals.deep-map0Apply a two-argument function through a shallow  , akin to .deep-map0Apply a two-argument function through a shallow  , akin to .deep-mapApply a two-argument  function through a deep  , akin to .deep-map%Half of the isomorphism of a depth-1  to a  . See also .deep-map%Half of the isomorphism of a depth-1  to a  . See also .deep-map A singleton  . Use with  to create deep nestings:"Outer" @> 0 @| [5]:Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}deep-mapInfix synonym for  . Use with  to create deep nestings:"Outer" @> 0 @| [5]:Nest {fromList [("Outer",Nest {fromList [(0,Bare [5])]})]}deep-mapO(1)&. The empty, arbitrary positive-depth .deep-mapO(1) . A depth-1  with a single key/value pair.deep-mapO(n). Return all submaps of the map in ascending order of its keys. Subject to list fusion.deep-mapO(n). Return all values of the singly-nested map in ascending order of its keys. Subject to list fusion.deep-mapO(n). Return all keys of the map in ascending order. Subject to list fusion.deep-mapO(n). Return all pairs of the map in ascending key order. Subject to list fusion.deep-mapO(n). Return all pairs of the singly-nested map in ascending key order. Subject to list fusion.deep-mapO(n)!. The set of all keys of the map.deep-map O(n log n). Build a deeper  from a list of key/ pairs. If the list contains more than one value for the same key, the values are combined using .!deep-map O(n log n). Build a depth-1  from a list of key/value pairs. If the list contains more than one value for the same key, the values are combined using ."deep-map O(n log n). Build a depth-2  from a list of keys and values. If the list contains more than one value for the same keys, the values are combined using .#deep-map O(n log n). Build a depth-3  from a list of keys and values. If the list contains more than one value for the same keys, the values are combined using .$deep-map O(n log n). Build a depth-4  from a list of keys and values. If the list contains more than one value for the same keys, the values are combined using .%deep-map O(n log n). Build a depth-5  from a list of keys and values. If the list contains more than one value for the same keys, the values are combined using .&deep-map O(n log n). Build a deeper  from a list of key/0 pairs using the provided combining function.'deep-map O(n log n). Build a depth-1  from a list of key/value pairs using the provided combining function.(deep-map O(n log n). Build a deeper  from a list of key/! pairs with a combining function.)deep-map O(n log n). Build a depth-1 : from a list of key/value pairs with a combining function.*deep-map O(n log n). Build a depth-2 : from a list of keys and values with a combining function.+deep-map O(n log n). Build a depth-3 : from a list of keys and values with a combining function.,deep-map O(n log n). Build a depth-3 : from a list of keys and values with a combining function.-deep-map O(n log n). Build a depth-3 : from a list of keys and values with a combining function..deep-mapO(log n). Insert a key/ pair into the . If the key is already present in the map, the associated value is combined with the new value as old  new$. The overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using 5.0deep-mapO(log n),. Insert a new key and value into a depth-1 . If the key is already present in the map, the associated value is combined with the new value as old  new$. The overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using 7.1deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-2 . If the key is already present in the map, the associated value is combined with the new value as old  new$. The overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using 8.2deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-3 . If the key is already present in the map, the associated value is combined with the new value as old  new'. so the overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using 9.3deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-4 . If the key is already present in the map, the associated value is combined with the new value as old  new'. so the overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using :.4deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-5 . If the key is already present in the map, the associated value is combined with the new value as old  new'. so the overwriting behaviour from  containers+ can be recovered by wrapping values in  or by using ;.5deep-mapO(log n). Insert a new key/ pair into the . If the key is already present in the map, the associated value is replaced by the new value.7deep-mapO(log n)-. Insert a new key/value pair into a depth-1 . If the key is already present in the map, the associated value is replaced by the new value.8deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-2 . If the key is already present in the map, the associated value is replaced by the new value.9deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-3 . If the key is already present in the map, the associated value is replaced by the new value.:deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-4 . If the key is already present in the map, the associated value is replaced by the new value.;deep-mapO(log n)3. Insert a new key-chain/value pair into a depth-5 . If the key is already present in the map, the associated value is replaced by the new value.<deep-mapO(log n)%. Combines replacement and retrieval.>deep-mapO(log n)0. Combines replacement and retrieval at depth 1.?deep-mapO(log n)0. Combines replacement and retrieval at depth 2.@deep-mapO(log n)0. Combines replacement and retrieval at depth 3.Adeep-mapO(log n)0. Combines replacement and retrieval at depth 4.Bdeep-mapO(log n)0. Combines replacement and retrieval at depth 5.Cdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.C (~~) k new m will insert new at k4 if there is no value present, or overwrite with  old ~~ new if there was already a value old at k.Ddeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.D (~~) k new m will insert new at k4 if there is no value present, or overwrite with  old ~~ new if there was already a value old at k.Edeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.Fdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.Gdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.Hdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.Ideep-mapO(log n). Insert with a function, combining new value and old value using the supplied function.I f k new m will insert new at k% if there is no value present, or  f k old new if there was already a value old at k. The key passed to f is the one passed to I!, not the one present in the map.Jdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.Kdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.Ldeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.Mdeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.Ndeep-mapO(log n). Insert with a function, combining new value and old value using the supplied function with access to the given keys.Odeep-mapO(log n)#. Combines insertion and retrieval. 'insertLookupWithKey' f k new == 'lookup' k &&& 'insertWithKey' f k newPdeep-mapO(log n)#. Combines insertion and retrieval.Qdeep-mapO(log n)#. Combines insertion and retrieval.Rdeep-mapO(log n)#. Combines insertion and retrieval.Sdeep-mapO(log n)#. Combines insertion and retrieval.Tdeep-mapO(log n)#. Combines insertion and retrieval.Udeep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.Wdeep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.Xdeep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.Ydeep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.Zdeep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.[deep-mapO(log n). Delete a key and its value from the map, or do nothing if the key is missing.\deep-mapO(log n). Change a value at a specific key with the result of the provided function, or do nothing if the key is missing.^deep-mapO(log n). Change a value at a specific key with the result of the provided function, or do nothing if the key is missing._deep-mapO(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.`deep-mapO(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.adeep-mapO(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.bdeep-mapO(log n). Change a value at specific keys with the result of the provided function, or do nothing if the key is missing.cdeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.ddeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.edeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.fdeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.gdeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.hdeep-mapO(log n). Change a value at a specific key with access to the key itself, or do nothing if the key is missing.ideep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.kdeep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.ldeep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.mdeep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.ndeep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.odeep-mapO(log n) . Change a 1 at a specific key. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.pdeep-mapO(log n) . Change a  at a specific key, with access to the key itself. If the function evaluates to , the key and submap are removed. If the key is missing, do nothing.qdeep-mapO(log n). Change a value at a specific key with access to the key itself. If the function evaluates to , the key and value are removed. If the key is missing, do nothing.rdeep-mapO(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to , the keys and value are removed. If the keys are missing, do nothing.sdeep-mapO(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to , the keys and value are removed. If the keys are missing, do nothing.tdeep-mapO(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to , the keys and value are removed. If the keys are missing, do nothing.udeep-mapO(log n). Change a value at specific keys with access to the keys themselves. If the function evaluates to , the keys and value are removed. If the keys are missing, do nothing.vdeep-mapO(log n) . Combines change and retrieval. ?'updateLookupWithKey' f k == 'lookup' k &&& 'updateWithKey' f kwdeep-mapO(log n) . Combines change and retrieval.xdeep-mapO(log n) . Combines change and retrieval.ydeep-mapO(log n) . Combines change and retrieval.zdeep-mapO(log n) . Combines change and retrieval.{deep-mapO(log n) . Combines change and retrieval.|deep-mapO(log n). Can be used to ., 5, U, or i a value.~deep-mapO(log n). Can be used to ., 5, U, or i a value.deep-mapO(log n). Can be used to ., 5, U, or i a value.deep-mapO(log n). Can be used to ., 5, U, or i a value.deep-mapO(log n). Can be used to ., 5, U, or i a value.deep-mapO(log n). Can be used to ., 5, U, or i a value.deep-mapO(log n). Lookup the value at a key.deep-mapO(log n). Lookup the value at a key.deep-mapO(log n). A flipped, infix variant of .deep-mapO(log n). A flipped, infix variant of .deep-mapO(log n)'. Facilitates chaining of lookups. For m :: DeepMap '[k0, k1, k2] v,>= (@? k1) >>= (@?| k2)deep-mapO(log n)'. Facilitates chaining of lookups. For m :: DeepMap '[k0, k1, k2] v,>= (@? k1) >>= (@?| k2)deep-mapO(log n). A version of  that returns " when the element cannot be found.deep-mapO(log n). A version of  that returns " when the element cannot be found.deep-mapO(log n) . Lookup the 0 at a key, with a default if the key is missing.deep-mapO(log n). Lookup the value at a key, with a default if the key is missing.deep-mapO(log n). Lookup the value at a key, with a default if the key is missing.deep-mapO(log n). Lookup the value at a key, with a default if the key is missing.deep-mapO(log n). Lookup the value at a key, with a default if the key is missing.deep-mapO(log n). Lookup the value at a key, with a default if the key is missing.deep-mapO(log n)+. Is the key a member of the map? See also .deep-mapO(log n),. Is the key missing from the map? See also .deep-mapFind the next smallest key to the given one, and return its key/value pair.deep-mapFind the next largest key to the given one, and return its key/value pair.deep-mapFind the largest key up to the given one, and return its key/value pair.deep-mapFind the smallest key down to the given one, and return its key/value pair.deep-mapO(1) . Is the  empty?deep-mapO(1)&. The number of outermost keys in the .deep-mapO(m log(n / m + 1)), m <= n . Join two s together using , to combine the values of duplicate keys. To retain "'s left-biased functionality, use  .deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n . Join two s with a combining function.deep-mapO(m log(n / m + 1)), m <= n. Join two maps with a combining function with access to the keys.deep-mapO(m log(n / m + 1)), m <= n . Join two 4s with a combining function with access to the keys.deep-mapO(m log(n / m + 1)), m <= n . Join two 4s with a combining function with access to the keys.deep-mapO(m log(n / m + 1)), m <= n . Join two 4s with a combining function with access to the keys.deep-mapO(m log(n / m + 1)), m <= n . Join two 4s with a combining function with access to the keys.deep-mapO(m log(n / m + 1)), m <= n . Join two 4s with a combining function with access to the keys.deep-mapA synonym for  . To retain 's functionality, use  .deep-mapThe union of a list of (s, combining with a specified operation.deep-mapThe union of a list of (s, combining with a specified operation.deep-mapO(m log(n / m + 1)), m <= n&. The set-difference of the keys in a -, keeping the values of the left-hand map.deep-mapInfix synonym for .deep-mapO(n + m). Difference with a combining function. Deletes keys if the value is .deep-mapO(n + m). Difference with a combining function. Deletes keys if the value is .deep-mapO(n + m). Difference with a combining function. Deletes keys if the value is .deep-mapO(n + m). Difference with a combining function. Deletes keys if the value is .deep-mapO(m log(n / m + 1)), m <= n. The set-intersection of the keys in a map, keeping the values of the left-hand map.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(m log(n / m + 1)), m <= n). Intersection with a combining function.deep-mapO(n). Strictly more general than 3 in that it may change the types of the inner keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Like / but the function has access to the outer keys.deep-mapO(n). Strictly more general than 3 in that it may change the types of the inner keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n)(. Traverse keys/submaps and collect the  results.deep-mapO(n)'. Traverse keys/values and collect the  results.deep-mapO(n)'. Traverse keys/values and collect the  results.deep-mapO(n)'. Traverse keys/values and collect the  results.deep-mapO(n)'. Traverse keys/values and collect the  results.deep-mapO(n)'. Traverse keys/values and collect the  results.deep-mapO(n).. Thread an accumulating argument through the  in ascending order of keys.deep-mapO(n).. Thread an accumulating argument through the  in ascending order of keys.deep-mapO(n).. Thread an accumulating argument through the  in descending order of keys.deep-mapO(n).. Thread an accumulating argument through the  in descending order of keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-mapO(n). Like ) but the function has access to the keys.deep-map O(n log n)*. Map a function over the outer keys of a &. If the function maps two or more j-keys to the same k-key, the values of the j-keys are combined with . To retain &'s greatest-biased functionality, use  .deep-map O(n log n)$. Map a function over the keys of a .deep-map O(n log n)$. Map a function over the keys of a .deep-map O(n log n)$. Map a function over the keys of a .deep-map O(n log n)$. Map a function over the keys of a .deep-map O(n log n)$. Map a function over the keys of a .deep-map O(n log n)*. Map a function over the outer keys of a  with a combining function.deep-map O(n log n)$. Map a function over the keys of a ! with a value-combining function.deep-map O(n log n)$. Map a function over the keys of a ! with a value-combining function.deep-map O(n log n)$. Map a function over the keys of a ! with a value-combining function.deep-map O(n log n)$. Map a function over the keys of a ! with a value-combining function.deep-map O(n log n)$. Map a function over the keys of a ! with a value-combining function.deep-map O(n log n). Map an applicative function over the outer keys and collect the results.deep-map O(n log n). Map an applicative function over the outer keys of the map and collect the results using the specified combining function.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.Sadly  traverseKeys2 can't have this type signature because we'd end up with a twice-wrapped  and no way out.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.deep-map O(n log n),. Map a monadic function over the keys of a  and collect the results.deep-map O(n log n)2. Map a monadic function over the outer keys of a " with a submap-combining function.deep-map O(n log n),. Map a monadic function over the keys of a ! with a value-combining function.deep-map O(n log n),. Map a monadic function over the keys of a ! with a value-combining function.deep-map O(n log n),. Map a monadic function over the keys of a ! with a value-combining function.deep-map O(n log n),. Map a monadic function over the keys of a ! with a value-combining function.deep-map O(n log n),. Map a monadic function over the keys of a ! with a value-combining function.deep-mapO(n)#. Fold the keys and submaps in the 3 using the given right-associative binary operator.deep-mapO(n). Fold the keys and values using the given right-associative binary operator.deep-mapO(n). Fold the keys and values using the given right-associative binary operator.deep-mapO(n). Fold the keys and values using the given right-associative binary operator.deep-mapO(n). Fold the keys and values using the given right-associative binary operator.deep-mapO(n). Fold the keys and values using the given right-associative binary operator.deep-mapO(n)#. Fold the keys and submaps in the 2 using the given left-associative binary operator.deep-mapO(n)". Fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)". Fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)". Fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)". Fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)+. Strictly fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n),. Strictly fold the keys and submaps in the 3 using the given right-associative binary operator.deep-mapO(n). Strictly fold the keys and values using the given right-associative binary operator.deep-mapO(n). Strictly fold the keys and values using the given right-associative binary operator.deep-mapO(n). Strictly fold the keys and values using the given right-associative binary operator.deep-mapO(n). Strictly fold the keys and values using the given right-associative binary operator.deep-mapO(n). Strictly fold the keys and values using the given right-associative binary operator.deep-mapO(n),. Strictly fold the keys and submaps in the 2 using the given left-associative binary operator.deep-mapO(n)+. Strictly fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)+. Strictly fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)+. Strictly fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)+. Strictly fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)". Fold the keys and values in the 2 using the given left-associative binary operator.deep-mapO(n)3. Fold the keys and submaps using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)3. Fold the keys and submaps using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n)=. Fold the keys and values in the map using the given monoid.deep-mapO(n). Convert the map to a list of key/submap pairs where the keys are in ascending order. Subject to list fusion.deep-mapO(n). Convert the map to a list of key/submap pairs where the keys are in descending order. Subject to list fusion.deep-mapO(n)0. Filter all submaps that satisfy the predicate.deep-mapO(n)/. Filter all values that satisfy the predicate.deep-mapO(n)/. Filter all values that satisfy the predicate.deep-mapO(n)/. Filter all values that satisfy the predicate.deep-mapO(n)/. Filter all values that satisfy the predicate.deep-mapO(n)/. Filter all values that satisfy the predicate.deep-mapO(n)9. Filter all key/submap pairs that satisfy the predicate.deep-mapO(n)8. Filter all key/value pairs that satisfy the predicate.deep-mapO(n)>. Filter all key-chain/value pairs that satisfy the predicate.deep-mapO(n)>. Filter all key-chain/value pairs that satisfy the predicate.deep-mapO(n)>. Filter all key-chain/value pairs that satisfy the predicate.deep-mapO(n)>. Filter all key-chain/value pairs that satisfy the predicate.deep-mapO(m log(n / m + 1)), m <= n . Restrict a  to only the keys in a given .deep-mapO(m log(n / m + 1)), m <= n . Restrict a  to only the keys in a given .deep-mapO(m log(n / m + 1)), m <= n . Restrict a  to only the keys in a given .deep-mapO(m log(n / m + 1)), m <= n . Restrict a  to only the keys in a given .deep-mapO(m log(n / m + 1)), m <= n . Restrict a  to only the keys in a given .deep-mapO(m log(n / m + 1)), m <= n. Remove all the keys in a  from a .deep-mapO(m log(n / m + 1)), m <= n. Remove all the keys in a  from a .deep-mapO(m log(n / m + 1)), m <= n. Remove all the keys in a  from a .deep-mapO(m log(n / m + 1)), m <= n. Remove all the keys in a  from a .deep-mapO(m log(n / m + 1)), m <= n. Remove all the keys in a  from a .deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n). Partition the map according to a predicate (satisfied, failed).deep-mapO(n)<. Take while a predicate on the keys holds. See the note at .deep-mapO(n)<. Drop while a predicate on the keys holds. See the note at .deep-mapO(n)+. Take while a predicate on the keys holds.NOTE:% if p is not actually antitone, then  will split the map at some unspecified point where the predicate switches from holding to not holding (where the predicate is seen to hold before the first key and to fail after the last key).deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the % results. Strictly more general than 0 in that the types of the inner keys can change.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  results.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(n). Map values and collect the  and  results separately.deep-mapO(log n). Partition the map by comparing keys ((smaller, larger) than given).deep-mapO(log n). Like  but the middle coordinate s the value at the key.deep-mapO(1). Decompose a map into pieces based on the structure of the underlying tree.deep-mapO(m log(n / m + 1)), m <= n . Returns 8 if all the keys in the left map exist in the right, and their values all agree.deep-mapO(m log(n / m + 1)), m <= n . Returns 8 if all the keys in the left map exist in the right, and the function returns # when applied to respective values.deep-mapO(m log(n / m + 1)), m <= n . Returns 8 if all the keys in the left map exist in the right, and their values all agree, and the maps are not equal.deep-mapO(m log(n / m + 1)), m <= n . Returns 8 if all the keys in the left map exist in the right, and the function returns ' when applied to respective values, and the maps are not equal.deep-mapO(log n) . Lookup the index of a key, which is its zero-based index in the ordered sequence of keys. 7'lookupIndex' k m == 'Data.List.findIndex' k ('keys' m)deep-mapO(log n) . Lookup the index of a key, which is its zero-based index in the ordered sequence of keys. Calls  when the key is not in the map.deep-mapO(log n). Retrieve an element by its index. Calls  if i is outside the range  0 <= i <  m.deep-mapO(log n). Update the element by its index. Calls  if i is outside the range  0 <= i <  m.deep-mapO(log n). Delete the element by its index. Calls  if i is outside the range  0 <= i <  m.deep-mapTake the smallest n keys.deep-mapDrop the smallest n keys.deep-mapO(n)$. Split a map at a particular index.deep-mapO(log n)!. The minimal key of the map, or  if the map is empty.deep-mapO(log n)!. The maximal key of the map, or  if the map is empty.deep-mapO(log n)!. The minimal key of the map, or  if the map is empty.deep-mapO(log n)!. The maximal key of the map, or  if the map is empty.deep-mapO(log n). Delete the minimal key.deep-mapO(log n). Delete the maximal key.deep-mapO(log n)3. Delete and return the minimal key of the map, or  if the map is empty.deep-mapO(log n)3. Delete and return the maximal key of the map, or  if the map is empty.deep-mapO(log n)&. Update the value at the minimal key.deep-mapO(log n)&. Update the value at the maximal key.deep-mapO(log n)&. Update the value at the minimal key.deep-mapO(log n)&. Update the value at the maximal key.deep-mapO(log n). Retrieve the value associated with the minimal key of the map, and the map stripped of that element, or  if passed an empty map.deep-mapO(log n). Retrieve the value associated with the maximal key of the map, and the map stripped of that element, or  if passed an empty map.deep-mapO(log n). Retrieve the minimal key/value pair of the map, and the map stripped of that element, or  if passed an empty map.deep-mapO(log n). Retrieve the maximal key/value pair of the map, and the map stripped of that element, or  if passed an empty map.deep-map Transpose a ), by swapping the outer two "dimensions".   !"#$%&'()*+,-./01234CDEFGHIJKLMNOPQRST56789:;<=>?@ABUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~    !"#$%&'()*+,-./01234CDEFGHIJKLMNOPQRST56789:;<=>?@ABUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~ 66      !"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\]^_`abcdefghijklmnopqrstuvwxyz{|}~&deep-map-0.2.0.1-JrVZSlYgzs3OciqBJXhEw Data.Map.Deepdeep-mapData.SemigroupLastDataMapbase Data.Foldablefoldrfoldr'foldlfoldl'toListDeepDeep1DeepMapBareNestgetBaregetNestDeep5Deep4Deep3Deep2onBare2onNest2toMapfromMap@>@|deepempty singletonelemselems1keysassocsassocs1keysSetfromList fromListDeep fromList1 fromList2 fromList3 fromList4 fromList5 fromListWith fromListWith1fromListWithKeyfromListWithKey1fromListWithKey2fromListWithKey3fromListWithKey4fromListWithKey5insert insertDeepinsert1insert2insert3insert4insert5 overwrite overwriteDeep overwrite1 overwrite2 overwrite3 overwrite4 overwrite5overwriteLookupoverwriteLookupDeepoverwriteLookup1overwriteLookup2overwriteLookup3overwriteLookup4overwriteLookup5 insertWith insertWith1 insertWith2 insertWith3 insertWith4 insertWith5 insertWithKeyinsertWithKey1insertWithKey2insertWithKey3insertWithKey4insertWithKey5insertLookupWithKeyinsertLookupWithKey1insertLookupWithKey2insertLookupWithKey3insertLookupWithKey4insertLookupWithKey5delete deleteDeepdelete1delete2delete3delete4delete5adjust adjustDeepadjust1adjust2adjust3adjust4adjust5 adjustWithKeyadjustWithKey1adjustWithKey2adjustWithKey3adjustWithKey4adjustWithKey5update updateDeepupdate1update2update3update4update5 updateWithKeyupdateWithKey1updateWithKey2updateWithKey3updateWithKey4updateWithKey5updateLookupWithKeyupdateLookupWithKey1updateLookupWithKey2updateLookupWithKey3updateLookupWithKey4updateLookupWithKey5alter alterDeepalter1alter2alter3alter4alter5alterF alterFDeepalterF1alterF2alterF3alterF4alterF5lookup lookupDeep@?@?|@??@??|@!@!|findWithDefaultfindWithDefault1findWithDefault2findWithDefault3findWithDefault4findWithDefault5member notMemberlookupLTlookupGTlookupLElookupGEnullsizeunion unionWith unionWith1 unionWith2 unionWith3 unionWith4 unionWith5 unionWithKey unionWithKey1 unionWithKey2 unionWithKey3 unionWithKey4 unionWithKey5unions unionsWith unionsWith1 difference\\differenceWithdifferenceWith1differenceWithKeydifferenceWithKey1 intersectionintersectionWithintersectionWith1intersectionWithKeyintersectionWithKey1intersectionWithKey2intersectionWithKey3intersectionWithKey4intersectionWithKey5 mapShallowmapShallowWithKey mapWithKey1 mapWithKey2 mapWithKey3 mapWithKey4 mapWithKey5traverseShallowtraverseShallowWithKeytraverseWithKey1traverseWithKey2traverseWithKey3traverseWithKey4traverseWithKey5traverseMaybeWithKeytraverseMaybeWithKey1traverseMaybeWithKey2traverseMaybeWithKey3traverseMaybeWithKey4traverseMaybeWithKey5mapAccum mapAccum1 mapAccumR mapAccumR1mapAccumWithKeymapAccumWithKey1mapAccumWithKey2mapAccumWithKey3mapAccumWithKey4mapAccumWithKey5mapAccumRWithKeymapAccumRWithKey1mapAccumRWithKey2mapAccumRWithKey3mapAccumRWithKey4mapAccumRWithKey5mapKeys mapKeysDeepmapKeys1mapKeys2mapKeys3mapKeys4mapKeys5 mapKeysWith mapKeysWith1 mapKeysWith2 mapKeysWith3 mapKeysWith4 mapKeysWith5 traverseKeystraverseKeysDeeptraverseKeysWithmapKeysM mapKeysM1 mapKeysM2 mapKeysM3 mapKeysM4 mapKeysM5 mapKeysMWith mapKeysMWith1 mapKeysMWith2 mapKeysMWith3 mapKeysMWith4 mapKeysMWith5 foldShallow foldrWithKey foldrWithKey1 foldrWithKey2 foldrWithKey3 foldrWithKey4 foldrWithKey5 foldlWithKey foldlWithKey1 foldlWithKey2 foldlWithKey3 foldlWithKey4 foldlWithKey5 foldrWithKey'foldrWithKey1'foldrWithKey2'foldrWithKey3'foldrWithKey4'foldrWithKey5' foldlWithKey'foldlWithKey1'foldlWithKey2'foldlWithKey3'foldlWithKey4'foldlWithKey5'foldMapWithKeyfoldMapWithKey1foldMapWithKey2foldMapWithKey3foldMapWithKey4foldMapWithKey5foldMapWithKey'foldMapWithKey1'foldMapWithKey2'foldMapWithKey3'foldMapWithKey4'foldMapWithKey5' toAscList toDescListfilterfilter1filter2filter3filter4filter5 filterWithKeyfilterWithKey1filterWithKey2filterWithKey3filterWithKey4filterWithKey5 restrictKeys restrictKeys2 restrictKeys3 restrictKeys4 restrictKeys5 withoutKeys withoutKeys2 withoutKeys3 withoutKeys4 withoutKeys5 partition partition1 partition2 partition3 partition4 partition5partitionWithKeypartitionWithKey1partitionWithKey2partitionWithKey3partitionWithKey4partitionWithKey5takeWhileAntitonedropWhileAntitone spanAntitonemapMaybemapShallowMaybemapShallowMaybeWithKeymapMaybeWithKey1mapMaybeWithKey2mapMaybeWithKey3mapMaybeWithKey4mapMaybeWithKey5 mapEithermapShallowEithermapShallowEitherWithKeymapEitherWithKey1mapEitherWithKey2mapEitherWithKey3mapEitherWithKey4mapEitherWithKey5split splitLookup splitRoot isSubmapOf isSubmapOfByisProperSubmapOfisProperSubmapOfBy lookupIndex findIndexelemAtupdateAtdeleteAttakedropsplitAt lookupMin lookupMaxfindMinfindMax deleteMin deleteMax deleteFindMin deleteFindMax updateMin updateMaxupdateMinWithKeyupdateMaxWithKeyminViewmaxViewminViewWithKeymaxViewWithKey invertKeys$fGenericDeepMap$fGenericDeepMap0 $fDataDeepMap$fDataDeepMap0$fMonoidDeepMap$fMonoidDeepMap0$fSemigroupDeepMap$fSemigroupDeepMap0 $fShowDeepMap$fShowDeepMap0 $fOrdDeepMap $fOrdDeepMap0 $fEqDeepMap $fEqDeepMap0!$fTraversableWithIndexDeepDeepMap$fFoldableWithIndexDeepDeepMap$fFunctorWithIndexDeepDeepMap $fOrdDeep$fEqDeep $fShowDeep $fOrdDeep0 $fEqDeep0$fTraversableDeepMap$fFoldableDeepMap$fFunctorDeepMapGHC.BaseliftA2onBare2Fcontainers-0.6.7Data.Map.Internal<> GHC.MaybeNothinglookup1memptyconstfoldfmapData.TraversabletraverseJust ApplicativeData.Set.InternalSet Data.EitherLeftRightghc-prim GHC.TypesTrueGHC.Errerror