Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

Exact lookup

1. mapAccumWithKey :: (a -> k -> b -> (a, c)) -> a -> Map k b -> (a, Map k c)

   rio	RIO.Map

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

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

   rio	RIO.Map

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

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

   rio	RIO.Map

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

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

   rio	RIO.Map

   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"
   

5. mapKeysWith :: Ord k2 => (a -> a -> a) -> (k1 -> k2) -> Map k1 a -> Map k2 a

   rio	RIO.Map

   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. The value at the greater of the two original keys is used as the first argument to 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"
   

   Also see the performance note on fromListWith.

6. mapMaybe :: (a -> Maybe b) -> Map k a -> Map k b

   rio	RIO.Map

   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"
   

7. mapMaybeWithKey :: (k -> a -> Maybe b) -> Map k a -> Map k b

   rio	RIO.Map

   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"
   

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

   rio	RIO.Map

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

9. mapKeysMonotonic :: (k1 -> k2) -> Map k1 a -> Map k2 a

   rio	RIO.Map.Unchecked

   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
   

10. mapLeft :: (a1 -> a2) -> Either a1 b -> Either a2 b

    rio	RIO.Prelude

    Apply a function to a Left constructor

Page 125 of many | Previous | Next