Map - BHC Documentation

empty :: Map k a { } #

O(1). The empty map.

singleton :: k -> a -> Map k a { } #

O(1). A map with a single element.

fromList :: (Ord k) => [(k, a)] -> Map k a { } #

O(n * log n). Build a map from a list of key-value pairs.

fromListWith :: (Ord k) => (a -> a -> a) -> [(k, a)] -> Map k a { } #

O(n * log n). Build a map from a list with a combining function.

fromListWithKey :: (Ord k) => (k -> a -> a -> a) -> [(k, a)] -> Map k a { } #

O(n * log n). Build a map from a list with a key-aware combining function.

lookup :: (Ord k) => k -> (Map k a) -> Maybe a { } #

O(log n). Lookup a value at a key in the map.

!? :: (Ord k) => (Map k a) -> k -> Maybe a { } #

O(log n). Flipped version of lookup.

m :: { } #

findWithDefault :: (Ord k) => a -> k -> (Map k a) -> a { } #

member :: (Ord k) => k -> (Map k a) -> Bool { } #

O(log n). Is the key a member of the map?

notMember :: (Ord k) => k -> (Map k a) -> Bool { } #

O(log n). Is the key not a member of the map?

null :: (Map k a) -> Bool { } #

O(1). Is the map empty?

size :: (Map k a) -> Int { } #

O(1). The number of elements in the map.

insert :: (Ord k) => k -> a -> (Map k a) -> Map k a { } #

O(log n). Insert a new key-value pair. If the key already exists,

insertWith :: (Ord k) => (a -> a -> a) -> k -> a -> (Map k a) -> Map k a { } #

O(log n). Insert with a combining function.

insertWithKey :: (Ord k) => (k -> a -> a -> a) -> k -> a -> (Map k a) -> Map k a { } #

O(log n). Insert with a key-aware combining function.

insertLookupWithKey :: (Ord k) => (k -> a -> a -> a) -> k -> a -> (Map k a) -> (Maybe a, Map k a) { } #

O(log n). Combine insert with lookup of the old value.

delete :: (Ord k) => k -> (Map k a) -> Map k a { } #

adjust :: (Ord k) => (a -> a) -> k -> (Map k a) -> Map k a { } #

O(log n). Adjust a value at a specific key with a function.

adjustWithKey :: (Ord k) => (k -> a -> a) -> k -> (Map k a) -> Map k a { } #

O(log n). Adjust a value with access to the key.

update :: (Ord k) => (a -> Maybe a) -> k -> (Map k a) -> Map k a { } #

O(log n). Update a value at a key. If the function returns Nothing,

updateWithKey :: (Ord k) => (k -> a -> Maybe a) -> k -> (Map k a) -> Map k a { } #

O(log n). Update a value with access to the key.

alter :: (Ord k) => ((Maybe a) -> Maybe a) -> k -> (Map k a) -> Map k a { } #

O(log n). The most general update function. Can insert, update, or delete.

alterF :: (Functor f, Ord k) => ((Maybe a) -> f (Maybe a)) -> k -> (Map k a) -> f (Map k a) { } #

O(log n). Functor-based alter. Useful for working with effects.

union :: (Ord k) => (Map k a) -> (Map k a) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Left-biased union of two maps.

unionWith :: (Ord k) => (a -> a -> a) -> (Map k a) -> (Map k a) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Union with a combining function.

unionWithKey :: (Ord k) => (k -> a -> a -> a) -> (Map k a) -> (Map k a) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Union with a key-aware combining function.

unions :: (Foldable f, Ord k) => (f (Map k a)) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Union of a foldable of maps.

unionsWith :: (Foldable f, Ord k) => (a -> a -> a) -> (f (Map k a)) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Union of maps with a combining function.

difference :: (Ord k) => (Map k a) -> (Map k b) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Difference of two maps.

differenceWith :: (Ord k) => (a -> b -> Maybe a) -> (Map k a) -> (Map k b) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Difference with a combining function.

differenceWithKey :: (Ord k) => (k -> a -> b -> Maybe a) -> (Map k a) -> (Map k b) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Difference with a key-aware combining function.

intersection :: (Ord k) => (Map k a) -> (Map k b) -> Map k a { } #

O(m * log(n\m + 1)), m <= n/. Intersection of two maps.

intersectionWith :: (Ord k) => (a -> b -> c) -> (Map k a) -> (Map k b) -> Map k c { } #

O(m * log(n\m + 1)), m <= n/. Intersection with a combining function.

intersectionWithKey :: (Ord k) => (k -> a -> b -> c) -> (Map k a) -> (Map k b) -> Map k c { } #

O(m * log(n\m + 1)), m <= n/. Intersection with a key-aware combining function.

map :: (a -> b) -> (Map k a) -> Map k b { } #

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

mapWithKey :: (k -> a -> b) -> (Map k a) -> Map k b { } #

O(n). Map a function over all values with access to the key.

traverseWithKey :: (Applicative t) => (k -> a -> t b) -> (Map k a) -> t (Map k b) { } #

O(n). Traverse the map with effects, providing access to keys.

mapAccum :: (a -> b -> (a, c)) -> a -> (Map k b) -> (a, Map k c) { } #

O(n). Thread an accumulating argument through the map in ascending order.

mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> (Map k b) -> (a, Map k c) { } #

O(n). Thread an accumulating argument with access to keys.

mapKeys :: (Ord k2) => (k1 -> k2) -> (Map k1 a) -> Map k2 a { } #

O(n * log n). Map a function over the keys.

mapKeysWith :: (Ord k2) => (a -> a -> a) -> (k1 -> k2) -> (Map k1 a) -> Map k2 a { } #

O(n * log n). Map over keys with a combining function for collisions.

mapKeysMonotonic :: (k1 -> k2) -> (Map k1 a) -> Map k2 a { } #

O(n). Map over keys with a strictly monotonic function.

foldr :: (a -> b -> b) -> b -> (Map k a) -> b { } #

O(n). Fold the values in the map using a right-associative operator.

foldl :: (a -> b -> a) -> a -> (Map k b) -> a { } #

O(n). Fold the values using a left-associative operator.

foldrWithKey :: (k -> a -> b -> b) -> b -> (Map k a) -> b { } #

O(n). Fold with access to keys, right-associative.

foldlWithKey :: (a -> k -> b -> a) -> a -> (Map k b) -> a { } #

O(n). Fold with access to keys, left-associative.

foldMapWithKey :: (Monoid m) => (k -> a -> m) -> (Map k a) -> m { } #

O(n). Fold the map into a monoid with access to keys.

elems :: (Map k a) -> [a] { } #

O(n). Return all values of the map in ascending key order.

keys :: (Map k a) -> [k] { } #

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

assocs :: (Map k a) -> [(k, a)] { } #

O(n). Return all key-value pairs in ascending key order.

keysSet :: (Map k a) -> Set.Set k { } #

O(n * log n). Convert the keys to a 'Set.Set'.

toList :: (Map k a) -> [(k, a)] { } #

O(n). Convert to a list of key-value pairs in ascending key order.

toAscList :: (Map k a) -> [(k, a)] { } #

O(n). Convert to an ascending list.

toDescList :: (Map k a) -> [(k, a)] { } #

O(n). Convert to a descending list.

filter :: (a -> Bool) -> (Map k a) -> Map k a { } #

O(n). Filter all values that satisfy a predicate.

filterWithKey :: (k -> a -> Bool) -> (Map k a) -> Map k a { } #

O(n). Filter with access to keys.

partition :: (a -> Bool) -> (Map k a) -> (Map k a, Map k a) { } #

O(n). Partition the map according to a predicate.

partitionWithKey :: (k -> a -> Bool) -> (Map k a) -> (Map k a, Map k a) { } #

O(n). Partition with access to keys.

mapMaybe :: (a -> Maybe b) -> (Map k a) -> Map k b { } #

O(n). Map and filter in a single pass.

mapMaybeWithKey :: (k -> a -> Maybe b) -> (Map k a) -> Map k b { } #

O(n). Map and filter with access to keys.

mapEither :: (a -> Either b c) -> (Map k a) -> (Map k b, Map k c) { } #

O(n). Map and split into two maps based on Either.

mapEitherWithKey :: (k -> a -> Either b c) -> (Map k a) -> (Map k b, Map k c) { } #

O(n). Map and split with access to keys.

isSubmapOf :: (Ord k, Eq a) => (Map k a) -> (Map k a) -> Bool { } #

O(n * log n). Is the first map a submap of the second?

isSubmapOfBy :: (Ord k) => (a -> b -> Bool) -> (Map k a) -> (Map k b) -> Bool { } #

O(n * log n). Submap check with a custom equality predicate.

isProperSubmapOf :: (Ord k, Eq a) => (Map k a) -> (Map k a) -> Bool { } #

O(n * log n). Is the first map a proper submap of the second?

isProperSubmapOfBy :: (Ord k) => (a -> b -> Bool) -> (Map k a) -> (Map k b) -> Bool { } #

O(n * log n). Proper submap check with a custom equality predicate.

lookupMin :: (Map k a) -> Maybe (k, a) { } #

O(log n). Lookup the smallest key and its value.

lookupMax :: (Map k a) -> Maybe (k, a) { } #

O(log n). Lookup the largest key and its value.

findMin :: (Map k a) -> (k, a) { } #

O(log n). Find the smallest key and its value.

findMax :: (Map k a) -> (k, a) { } #

O(log n). Find the largest key and its value.

deleteMin :: (Map k a) -> Map k a { } #

O(log n). Delete the smallest key. Returns the empty map if empty.

deleteMax :: (Map k a) -> Map k a { } #

O(log n). Delete the largest key. Returns the empty map if empty.

split :: (Ord k) => k -> (Map k a) -> (Map k a, Map k a) { } #

O(log n). Split the map at a key. Returns maps with keys less than

splitLookup :: (Ord k) => k -> (Map k a) -> (Map k a, Maybe a, Map k a) { } #

balance :: k -> a -> (Map k a) -> (Map k a) -> Map k a { } #

link :: k -> a -> (Map k a) -> (Map k a) -> Map k a { } #

insertMin :: k -> a -> (Map k a) -> Map k a { } #

insertMax :: k -> a -> (Map k a) -> Map k a { } #

glue :: (Map k a) -> (Map k a) -> Map k a { } #

otherwise :: { } #

merge :: (Map k a) -> (Map k a) -> Map k a { } #