Hoogle Search

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

mapEither :: (a -> Either b c) -> Word64Map a -> (Word64Map b, Word64Map c)

ghc-lib-parser	GHC.Data.Word64Map.Internal

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 :: (Key -> a -> Either b c) -> Word64Map a -> (Word64Map b, Word64Map c)

ghc-lib-parser	GHC.Data.Word64Map.Internal

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

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

ghc-lib-parser GHC.Data.Word64Map.Internal

Map covariantly over a WhenMatched f k x, using only a 'Functor f' constraint.
mapGentlyWhenMissing :: forall (f :: Type -> Type) a b x . Functor f => (a -> b) -> WhenMissing f x a -> WhenMissing f x b

ghc-lib-parser GHC.Data.Word64Map.Internal

Map covariantly over a WhenMissing f x, using only a 'Functor f' constraint.
mapKeys :: (Key -> Key) -> Word64Map a -> Word64Map a

ghc-lib-parser GHC.Data.Word64Map.Internal

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 :: (Key -> Key) -> Word64Map a -> Word64Map a

ghc-lib-parser GHC.Data.Word64Map.Internal

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 slightly better performance than mapKeys.
```
mapKeysMonotonic (\ k -> k * 2) (fromList [(5,"a"), (3,"b")]) == fromList [(6, "b"), (10, "a")]
```
mapKeysWith :: (a -> a -> a) -> (Key -> Key) -> Word64Map a -> Word64Map a

ghc-lib-parser GHC.Data.Word64Map.Internal

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"
```
mapMaybe :: (a -> Maybe b) -> Word64Map a -> Word64Map b

ghc-lib-parser GHC.Data.Word64Map.Internal

Map values and collect the Just results.
```
let f x = if x == "a" then Just "new a" else Nothing
mapMaybe f (fromList [(5,"a"), (3,"b")]) == singleton 5 "new a"
```
mapMaybeMissing :: forall (f :: Type -> Type) x y . Applicative f => (Key -> x -> Maybe y) -> WhenMissing f x y

ghc-lib-parser GHC.Data.Word64Map.Internal

Map over the entries whose keys are missing from the other map, optionally removing some. This is the most powerful SimpleWhenMissing tactic, but others are usually more efficient.
```
mapMaybeMissing :: (Key -> x -> Maybe y) -> SimpleWhenMissing x y
```
```
mapMaybeMissing f = traverseMaybeMissing (\k x -> pure (f k x))
```
but mapMaybeMissing uses fewer unnecessary Applicative operations.
mapMaybeWithKey :: (Key -> a -> Maybe b) -> Word64Map a -> Word64Map b

ghc-lib-parser GHC.Data.Word64Map.Internal

Map keys/values and collect the Just results.
```
let f k _ = if k < 5 then Just ("key : " ++ (show k)) else Nothing
mapMaybeWithKey f (fromList [(5,"a"), (3,"b")]) == singleton 3 "key : 3"
```

Page 178 of many | Previous | Next