Intervals with endpoints of type a.

Read and Show use mathematical notation with square brackets for closed and parens for open intervals. This is better for human readability, but is not a valid Haskell expression. Closed intervals look like a list, open intervals look like a tuple, and half-open intervals look like mismatched parens.

O(log n). Lookup value for given key. Calls error if the key is not in the map.

Use lookup or findWithDefault instead of this function, unless you are absolutely sure that the key is present in the map.

Same as difference.

O(1). Is the map empty?

O(n). Number of keys in the map.

Caution: unlike size, which takes constant time, this is linear in the number of keys!

O(log n). Does the map contain the given key? See also notMember.

O(log n). Does the map not contain the given key? See also member.

O(log n). Look up the given key in the map, returning the value (Just value), or Nothing if the key is not in the map.

O(log n). The expression (findWithDefault def k map) returns the value at key k or returns default value def when the key is not in the map.

findWithDefault 'x' 1 (fromList [(5,'a'), (3,'b')]) == 'x'
findWithDefault 'x' 5 (fromList [(5,'a'), (3,'b')]) == 'a'

O(log n). Find the largest key smaller than the given one and return it along with its value.

O(log n). Find the smallest key larger than the given one and return it along with its value.

O(log n). Find the largest key equal to or smaller than the given one and return it along with its value.

O(log n). Find the smallest key larger than the given one and return it along with its value.

Return the submap of key intervals containing the given point. This is the second element of the value of splitAt:

m `containing` p == let (_,m',_) = m `splitAt` p in m'

O(n), since potentially all keys could contain the point. O(log n) average case. This is also the worst case for maps containing no overlapping keys.

Return the submap of key intervals overlapping (intersecting) the given interval. This is the second element of the value of splitIntersecting:

m `intersecting` i == let (_,m',_) = m `splitIntersecting` i in m'

O(n), since potentially all keys could intersect the interval. O(log n) average case, if few keys intersect the interval.

Return the submap of key intervals completely inside the given interval.

O(n), since potentially all keys could be inside the interval. O(log n) average case, if few keys are inside the interval.

O(1). The empty map.

O(1). A map with one entry.

O(log n). Insert a new key/value pair. If the map already contains the key, its value is changed to the new value.

O(log n). Insert with a function, combining new value and old value. insertWith f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f new_value old_value).

O(log n). Insert with a function, combining key, new value and old value. insertWithKey f key value mp will insert the pair (key, value) into mp if key does not exist in the map. If the key does exist, the function will insert the pair (key, f key new_value old_value). Note that the key passed to f is the same key passed to insertWithKey.

O(log n). Combine insert with old values retrieval.

O(log n). Delete a key from the map. If the map does not contain the key, it is returned unchanged.

O(log n). Update a value at a specific key with the result of the provided function. When the key is not a member of the map, the original map is returned.

O(log n). Adjust a value at a specific key. When the key is not a member of the map, the original map is returned.

O(log n). The expression (update f k map) updates the value x at k (if it is in the map). If (f x) is Nothing, the element is deleted. If it is (Just y), the key k is bound to the new value y.

O(log n). The expression (updateWithKey f k map) updates the value x at k (if it is in the map). If (f k x) is Nothing, the element is deleted. If it is (Just y), the key k is bound to the new value y.

O(log n). Lookup and update. See also updateWithKey. The function returns changed value, if it is updated. Returns the original key value if the map entry is deleted.

O(log n). The expression (alter f k map) alters the value x at k, or absence thereof. alter can be used to insert, delete, or update a value in a Map. In short : lookup k (alter f k m) = f (lookup k m).

O(n+m). The expression (union t1 t2) takes the left-biased union of t1 and t2. It prefers t1 when duplicate keys are encountered, i.e. (union == unionWith const).

O(n+m). Union with a combining function.

O(n+m). Union with a combining function.

The union of a list of maps: (unions == foldl union empty).

The union of a list of maps, with a combining operation: (unionsWith f == foldl (unionWith f) empty).

O(n+m). Difference of two maps. Return elements of the first map not existing in the second map.

O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the values of these keys. If it returns Nothing, the element is discarded (proper set difference). If it returns (Just y), the element is updated with a new value y.

O(n+m). Difference with a combining function. When two equal keys are encountered, the combining function is applied to the key and both values. If it returns Nothing, the element is discarded (proper set difference). If it returns (Just y), the element is updated with a new value y.

O(n+m). Intersection of two maps. Return data in the first map for the keys existing in both maps. (intersection m1 m2 == intersectionWith const m1 m2).

O(n+m). Intersection with a combining function.

O(n+m). Intersection with a combining function.

O(n). Map a function over all values in the map.

O(n). Map a function over all values in the map.

O(n). The function mapAccum threads an accumulating argument through the map in ascending order of keys.

let f a b = (a ++ b, b ++ "X")
mapAccum f "Everything: " (fromList [(5,"a"), (3,"b")]) == ("Everything: ba", fromList [(3, "bX"), (5, "aX")])

O(n). The function mapAccumWithKey threads an accumulating argument through the map in ascending order of keys.

let f a k b = (a ++ " " ++ (show k) ++ "-" ++ b, b ++ "X")
mapAccumWithKey f "Everything:" (fromList [(5,"a"), (3,"b")]) == ("Everything: 3-b 5-a", fromList [(3, "bX"), (5, "aX")])

O(n). The function mapAccumRWithKey threads an accumulating argument through the map in descending order of keys.

O(n log n). mapKeys f s is the map obtained by applying f to each key of s.

The size of the result may be smaller if f maps two or more distinct keys to the same new key. In this case the value at the smallest of these keys is retained.

O(n log n). mapKeysWith c f s is the map obtained by applying f to each key of s.

The size of the result may be smaller if f maps two or more distinct keys to the same new key. In this case the associated values will be combined using c.

O(n). mapKeysMonotonic f s == mapKeys f s, but works only when f is strictly monotonic. That is, for any values x and y, if x < y then f x < f y. The precondition is not checked.

O(n). Fold the values in the map using the given right-associative binary operator, such that foldr f z == foldr f z . elems.

O(n). Fold the values in the map using the given left-associative binary operator, such that foldl f z == foldl f z . elems.

O(n). Fold the keys and values in the map using the given right-associative binary operator, such that foldrWithKey f z == foldr (uncurry f) z . toAscList.

O(n). Fold the keys and values in the map using the given left-associative binary operator, such that foldlWithKey f z == foldl (\z' (kx, x) -> f z' kx x) z . toAscList.

O(n). Join overlapping intervals with combine.

flattenWith (+) (fromList [([1,3],5), ([4,6],2), ([5,8],9)]) == mkMap [([1,3],5), ([4,8],11)]

O(n). List of all values in the map, in ascending order of their keys.

O(n). List of all keys in the map, in ascending order.

O(n). Set of the keys.

Same as toAscList.

O(n). The list of all key/value pairs contained in the map, in no particular order.

O(n log n). Build a map from a list of key/value pairs. See also fromAscList. If the list contains more than one value for the same key, the last value for the key is retained.

O(n log n). Build a map from a list of key/value pairs with a combining function. See also fromAscListWith.

O(n log n). Build a map from a list of key/value pairs with a combining function. See also fromAscListWith.

O(n). The list of all key/value pairs contained in the map, in ascending order of keys.

O(n). The list of all key/value pairs contained in the map, in descending order of keys.

O(n). Build a map from an ascending list in linear time. The precondition (input list is ascending) is not checked.

O(n). Build a map from an ascending list in linear time with a combining function for equal keys. The precondition (input list is ascending) is not checked.

O(n). Build a map from an ascending list in linear time with a combining function for equal keys. The precondition (input list is ascending) is not checked.

O(n). Build a map from an ascending list of elements with distinct keys in linear time. The precondition is not checked.

O(n). Filter values satisfying a predicate.

O(n). Filter keys/values satisfying a predicate.

O(n). Partition the map according to a predicate. The first map contains all elements that satisfy the predicate, the second all elements that fail the predicate. See also split.

O(n). Partition the map according to a predicate. The first map contains all elements that satisfy the predicate, the second all elements that fail the predicate. See also split.

O(n). Map values and collect the Just results.

O(n). Map keys/values and collect the Just results.

O(n). Map values and separate the Left and Right results.

O(n). Map keys/values and separate the Left and Right results.

O(n). The expression (split k map) is a pair (map1,map2) where the keys in map1 are smaller than k and the keys in map2 larger than k. Any key equal to k is found in neither map1 nor map2.

O(n). The expression (splitLookup k map) splits a map just like split but also returns lookup k map.

O(n). Split around a point. Splits the map into three submaps: intervals below the point, intervals containing the point, and intervals above the point.

O(n). Split around an interval. Splits the set into three subsets: intervals below the given interval, intervals intersecting the given interval, and intervals above the given interval.

O(n+m). This function is defined as (isSubmapOf = isSubmapOfBy (==)).

O(n+m). The expression (isSubmapOfBy f t1 t2) returns True if all keys in t1 are in tree t2, and f returns True when applied to their respective values.

O(n+m). Is this a proper submap? (ie. a submap but not equal). Defined as (isProperSubmapOf = isProperSubmapOfBy (==)).

O(n+m). Is this a proper submap? (ie. a submap but not equal). The expression (isProperSubmapOfBy f m1 m2) returns True when m1 and m2 are not equal, all keys in m1 are in m2, and when f returns True when applied to their respective values.

O(log n). Returns the smallest key and its associated value. Calls error if the map is empty.

O(log n). Returns the largest key and its associated value. Calls error if the map is empty.

Returns the key with the largest endpoint and its associated value. If there is more than one key with that endpoint, return the rightmost.

O(n), since all keys could have the same endpoint. O(log n) average case.

O(log n). Remove the smallest key from the map. Return the empty map if the map is empty.

O(log n). Remove the largest key from the map. Return the empty map if the map is empty.

O(log n). Delete and return the smallest key.

O(log n). Delete and return the largest key.

O(log n). Update or delete value at minimum key.

O(log n). Update or delete value at maximum key.

O(log n). Update or delete value at minimum key.

O(log n). Update or delete value at maximum key.

O(log n). Retrieves the value associated with minimal key of the map, and the map stripped of that element, or Nothing if passed an empty map.

O(log n). Retrieves the value associated with maximal key of the map, and the map stripped of that element, or Nothing if passed an empty map.

O(log n). Retrieves the minimal (key,value) pair of the map, and the map stripped of that element, or Nothing if passed an empty map.

minViewWithKey (fromList [([5,6],"a"), ([3,4],"b")]) == Just (([3,4],"b"), singleton [5,6] "a")
minViewWithKey empty == Nothing

O(log n). Retrieves the maximal (key,value) pair of the map, and the map stripped of that element, or Nothing if passed an empty map.

Check red-black-tree and interval search augmentation invariants. For testing/debugging only.

The height of the tree. For testing/debugging only.

The maximum height of a red-black tree with the given number of nodes. For testing/debugging only.

Tree statistics (size, height, maxHeight size). For testing/debugging only.