Hoogle Search

Within LTS Haskell 24.19 (ghc-9.10.3)

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

Exact lookup

1. mapEitherWithKey :: (Key -> a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)

   containers	Data.IntMap.Strict.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")])
   

2. mapKeys :: (Key -> Key) -> IntMap a -> IntMap a

   containers	Data.IntMap.Strict.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"
   

3. mapKeysMonotonic :: (Key -> Key) -> IntMap a -> IntMap a

   containers	Data.IntMap.Strict.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")]
   

4. mapKeysWith :: (a -> a -> a) -> (Key -> Key) -> IntMap a -> IntMap a

   containers	Data.IntMap.Strict.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"
   

   Also see the performance note on fromListWith.

5. mapMaybe :: (a -> Maybe b) -> IntMap a -> IntMap b

   containers	Data.IntMap.Strict.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"
   

6. mapMaybeWithKey :: (Key -> a -> Maybe b) -> IntMap a -> IntMap b

   containers	Data.IntMap.Strict.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"
   

7. mapWithKey :: (Key -> a -> b) -> IntMap a -> IntMap b

   containers	Data.IntMap.Strict.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")]
   

8. mapMonotonic :: (Key -> Key) -> IntSet -> IntSet

   containers	Data.IntSet

   The mapMonotonic f s == map f s, but works only when f is strictly increasing. The precondition is not checked. Semi-formally, we have:

   and [x < y ==> f x < f y | x <- ls, y <- ls]
   ==> mapMonotonic f s == map f s
   where ls = toList s
   

9. mapMonotonic :: (Key -> Key) -> IntSet -> IntSet

   containers	Data.IntSet.Internal

   The mapMonotonic f s == map f s, but works only when f is strictly increasing. The precondition is not checked. Semi-formally, we have:

   and [x < y ==> f x < f y | x <- ls, y <- ls]
   ==> mapMonotonic f s == map f s
   where ls = toList s
   

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

    containers	Data.Map.Internal

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

Page 56 of many | Previous | Next