Hoogle Search

Within LTS Haskell 24.39 (ghc-9.10.3)

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

Exact lookup

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

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

3. mapMissing :: forall (f :: Type -> Type) k x y . Applicative f => (k -> x -> y) -> WhenMissing f k x y

   containers	Data.Map.Strict.Internal

   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 k x y . Functor f => (a -> b) -> WhenMatched f k x y a -> WhenMatched f k x y b

   containers	Data.Map.Strict.Internal

   Map covariantly over a WhenMatched f k x y.

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

   containers	Data.Map.Strict.Internal

   Map covariantly over a WhenMissing f k x.

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

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

7. mapWithIndex :: (Int -> a -> b) -> Seq a -> Seq b

   containers	Data.Sequence

   A generalization of fmap, mapWithIndex takes a mapping function that also depends on the element's index, and applies it to every element in the sequence.

8. mapWithIndex :: (Int -> a -> b) -> Seq a -> Seq b

   containers	Data.Sequence.Internal

   A generalization of fmap, mapWithIndex takes a mapping function that also depends on the element's index, and applies it to every element in the sequence.

9. mapMonotonic :: (a -> b) -> Set a -> Set b

   containers	Data.Set

   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. mapMonotonic :: (a -> b) -> Set a -> Set b

    containers	Data.Set.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
    

Page 63 of many | Previous | Next