Hoogle Search

Within LTS Haskell 24.32 (ghc-9.10.3)

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

Exact lookup

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

   containers	Data.IntMap.Lazy

   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.

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

   containers	Data.IntMap.Lazy

   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"
   

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

   containers	Data.IntMap.Lazy

   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"
   

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

   containers	Data.IntMap.Lazy

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

5. mapMaybeMissing :: forall (f :: Type -> Type) x y . Applicative f => (Key -> x -> Maybe y) -> WhenMissing f x y

   containers	Data.IntMap.Merge.Lazy

   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.

6. mapMissing :: forall (f :: Type -> Type) x y . Applicative f => (Key -> x -> y) -> WhenMissing f x y

   containers	Data.IntMap.Merge.Lazy

   Map over the entries whose keys are missing from the other map.

   mapMissing :: (k -> x -> y) -> SimpleWhenMissing x y
   

   mapMissing f = mapMaybeMissing (\k x -> Just $ f k x)
   

   but mapMissing is somewhat faster.

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

   containers	Data.IntMap.Merge.Lazy

   Map covariantly over a WhenMatched f x y.

8. mapWhenMissing :: forall (f :: Type -> Type) a b x . (Applicative f, Monad f) => (a -> b) -> WhenMissing f x a -> WhenMissing f x b

   containers	Data.IntMap.Merge.Lazy

   Map covariantly over a WhenMissing f x.

9. mapMaybeMissing :: forall (f :: Type -> Type) x y . Applicative f => (Key -> x -> Maybe y) -> WhenMissing f x y

   containers	Data.IntMap.Merge.Strict

   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 :: (k -> x -> Maybe y) -> SimpleWhenMissing k x y
   

   mapMaybeMissing f = traverseMaybeMissing (\k x -> pure (f k x))
   

   but mapMaybeMissing uses fewer unnecessary Applicative operations.

10. mapMissing :: forall (f :: Type -> Type) x y . Applicative f => (Key -> x -> y) -> WhenMissing f x y

    containers	Data.IntMap.Merge.Strict

    Map over the entries whose keys are missing from the other map.

    mapMissing :: (k -> x -> y) -> SimpleWhenMissing k x y
    

    mapMissing f = mapMaybeMissing (\k x -> Just $ f k x)
    

    but mapMissing is somewhat faster.

Page 89 of many | Previous | Next