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. 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.

2. 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.

3. 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.

4. 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.Strict

   Map covariantly over a WhenMatched f k x y.

5. mapWhenMissing :: forall (f :: Type -> Type) a b x . Functor f => (a -> b) -> WhenMissing f x a -> WhenMissing f x b

   containers	Data.IntMap.Merge.Strict

   Map covariantly over a WhenMissing f k x.

6. mapAccum :: (a -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)

   containers	Data.IntMap.Strict

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

7. mapAccumRWithKey :: (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)

   containers	Data.IntMap.Strict

   The function mapAccumRWithKey threads an accumulating argument through the map in descending order of keys.

8. mapAccumWithKey :: (a -> Key -> b -> (a, c)) -> a -> IntMap b -> (a, IntMap c)

   containers	Data.IntMap.Strict

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

9. mapEither :: (a -> Either b c) -> IntMap a -> (IntMap b, IntMap c)

   containers	Data.IntMap.Strict

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

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

    containers	Data.IntMap.Strict

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

Page 54 of many | Previous | Next