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.

  1. zipWithMaybeMatched :: forall (f :: Type -> Type) k x y z . Applicative f => (k -> x -> y -> Maybe z) -> WhenMatched f k x y z

    containers Data.Map.Merge.Strict

    When a key is found in both maps, apply a function to the key and values and maybe use the result in the merged map. 

    zipWithMaybeMatched :: (k -> x -> y -> Maybe z)
-> SimpleWhenMatched k x y z

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

    containers Data.Map.Strict

    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 :: (k -> a -> Maybe b) -> Map k a -> Map k b

    containers Data.Map.Strict

    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. traverseMaybeWithKey :: Applicative f => (k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)

    containers Data.Map.Strict

    Traverse keys/values and collect the Just results.

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

    containers Data.Map.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. mapMaybeMissing :: forall (f :: Type -> Type) k x y . Applicative f => (k -> x -> Maybe y) -> WhenMissing f k x y

    containers Data.Map.Strict.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 :: (k -> x -> Maybe y) -> SimpleWhenMissing k x y

    mapMaybeMissing f = traverseMaybeMissing (\k x -> pure (f k x))
    but mapMaybeMissing uses fewer unnecessary Applicative operations.

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

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

  8. traverseMaybeMissing :: Applicative f => (k -> x -> f (Maybe y)) -> WhenMissing f k x y

    containers Data.Map.Strict.Internal

    Traverse over the entries whose keys are missing from the other map, optionally producing values to put in the result. This is the most powerful WhenMissing tactic, but others are usually more efficient.

  9. traverseMaybeWithKey :: Applicative f => (k -> a -> f (Maybe b)) -> Map k a -> f (Map k b)

    containers Data.Map.Strict.Internal

    Traverse keys/values and collect the Just results.

  10. zipWithMaybeAMatched :: Applicative f => (k -> x -> y -> f (Maybe z)) -> WhenMatched f k x y z

    containers Data.Map.Strict.Internal

    When a key is found in both maps, apply a function to the key and values, perform the resulting action, and maybe use the result in the merged map. This is the fundamental WhenMatched tactic.

Page 105 of many | Previous | Next