Hoogle Search

Note that Stackage only displays results for the latest LTS and Nightly snapshot. Learn more.

mapWhenMatched :: forall (f :: Type -> Type) a b k x y . Functor f => (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

containers Data.Map.Internal

Map covariantly over a WhenMatched f k x y.
mapWhenMissing :: forall (f :: Type -> Type) a b k x . (Applicative f, Monad f) => (a -> b) -> WhenMissing f k x a -> WhenMissing f k x b

containers Data.Map.Internal

Map covariantly over a WhenMissing f k x.

mapWithKey :: (k -> a -> b) -> Map k a -> Map k b

containers	Data.Map.Internal

Map a function over all values in the map.

let f key x = (show key) ++ ":" ++ x
mapWithKey f (fromList [(5,"a"), (3,"b")]) == fromList [(3, "3:b"), (5, "5:a")]

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

containers Data.Map.Lazy

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")])
```
mapAccumRWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)

containers Data.Map.Lazy

The function mapAccumRWithKey threads an accumulating argument through the map in descending order of keys.
mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)

containers Data.Map.Lazy

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")])
```

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

containers	Data.Map.Lazy

Map values and separate the Left and Right results.

let f a = if a < "c" then Left a else Right a
mapEither f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
== (fromList [(3,"b"), (5,"a")], fromList [(1,"x"), (7,"z")])

mapEither (\ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
== (empty, fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])

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

containers	Data.Map.Lazy

Map keys/values and separate the Left and Right results.

let f k a = if k < 5 then Left (k * 2) else Right (a ++ a)
mapEitherWithKey f (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
== (fromList [(1,2), (3,6)], fromList [(5,"aa"), (7,"zz")])

mapEitherWithKey (\_ a -> Right a) (fromList [(5,"a"), (3,"b"), (1,"x"), (7,"z")])
== (empty, fromList [(1,"x"), (3,"b"), (5,"a"), (7,"z")])

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

containers Data.Map.Lazy

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"
```
mapKeysMonotonic :: (k1 -> k2) -> Map k1 a -> Map k2 a

containers Data.Map.Lazy

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
where ls = keys 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
```

Page 94 of many | Previous | Next