(a -> Bool) -> Map k a -> Map k a

filter :: (a -> Bool) -> Map k a -> Map k a
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Filter all values that satisfy the predicate. > filter (> "a") (fromList [(5,"a"), (3,"b")]) == singleton 3 "b" > filter (> "x") (fromList [(5,"a"), (3,"b")]) == empty > filter (< "a") (fromList [(5,"a"), (3,"b")]) == empty
elfilter :: DynGraph gr => (b -> Bool) -> gr a b -> gr a b
fgl Data.Graph.Inductive.Basic
Filter based on edge label property.
map :: (a -> b) -> Map k a -> Map k b
containers Data.Map.Lazy, containers Data.Map.Strict
O(n). Map a function over all values in the map. > map (++ "x") (fromList [(5,"a"), (3,"b")]) == fromList [(3, "bx"), (5, "ax")]
adjust :: Ord k => (a -> a) -> k -> Map k a -> Map k a
containers Data.Map.Lazy, containers Data.Map.Strict
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. > adjust ("new " ++) 5 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "new a")] > adjust ("new " ++) 7 (fromList [(5,"a"), (3,"b")]) == fromList [(3, "b"), (5, "a")] > adjust ("new " ++) 7 empty == empty
emap :: DynGraph gr => (b -> c) -> gr a b -> gr a c
fgl Data.Graph.Inductive.Graph
Map a function over the Edge labels in a graph.
(^<<) :: Arrow a => (c -> d) -> a b c -> a b d
base Control.Arrow
Postcomposition with a pure function (right-to-left variant).
(>>^) :: Arrow a => a b c -> (c -> d) -> a b d
base Control.Arrow
Postcomposition with a pure function.
mapKeysMonotonic :: (k1 -> k2) -> Map k1 a -> Map k2 a
containers Data.Map.Lazy, containers Data.Map.Strict
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. Semi-formally, we have: > and [x < y ==> f x < f y | x <- ls, y <- ls] > ==> mapKeysMonotonic f s == mapKeys f s > This means that f maps distinct original keys to distinct resulting keys. This function has better performance than mapKeys. > mapKeysMonotonic (\ k -> k * 2) (fromList [(5,"a"), (3,"b")]) == fromList [(6, "b"), (10, "a")] > valid (mapKeysMonotonic (\ k -> k * 2) (fromList [(5,"a"), (3,"b")])) == True > valid (mapKeysMonotonic (\ _ -> 1) (fromList [(5,"a"), (3,"b")])) == False
nmap :: DynGraph gr => (a -> c) -> gr a b -> gr c b
fgl Data.Graph.Inductive.Graph
Map a function over the Node labels in a graph.
(^>>) :: Arrow a => (b -> c) -> a c d -> a b d
base Control.Arrow
Precomposition with a pure function.
mapKeys :: Ord k2 => (k1 -> k2) -> Map k1 a -> Map k2 a
containers Data.Map.Lazy, containers Data.Map.Strict
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 greatest of the original keys is retained. > mapKeys (+ 1) (fromList [(5,"a"), (3,"b")]) == fromList [(4, "b"), (6, "a")] > mapKeys (\ _ -> 1) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 1 "c" > mapKeys (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 3 "c"
(<<^) :: Arrow a => a c d -> (b -> c) -> a b d
base Control.Arrow
Precomposition with a pure function (right-to-left variant).
amap :: (IArray a e', IArray a e, Ix i) => (e' -> e) -> a i e' -> a i e
array Data.Array.IArray
Returns a new array derived from the original array by applying a function to each of the elements.
mapKeysWith :: Ord k2 => (a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a
containers Data.Map.Lazy, containers Data.Map.Strict
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. > mapKeysWith (++) (\ _ -> 1) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 1 "cdab" > mapKeysWith (++) (\ _ -> 3) (fromList [(1,"b"), (2,"a"), (3,"d"), (4,"c")]) == singleton 3 "cdab"
mapArray :: (MArray a e' m, MArray a e m, Ix i) => (e' -> e) -> a i e' -> m (a i e)
array Data.Array.MArray, array Data.Array.MArray.Safe
Constructs a new array derived from the original array by applying a function to each of the elements.
ixmap :: (IArray a e, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> a i e
array Data.Array.IArray
Returns a new array derived from the original array by applying a function to each of the indices.
mapIndices :: (MArray a e m, Ix i, Ix j) => (i, i) -> (i -> j) -> a j e -> m (a i e)
array Data.Array.MArray, array Data.Array.MArray.Safe
Constructs a new array derived from the original array by applying a function to each of the indices.