Hoogle Search

Within LTS Haskell 24.34 (ghc-9.10.3)

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

Exact lookup

1. mapMaybe :: (a -> Maybe b) -> Word64Map a -> Word64Map b

   ghc-lib-parser	GHC.Data.Word64Map.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"
   

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

   ghc-lib-parser	GHC.Data.Word64Map.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 :: (Key -> x -> Maybe y) -> SimpleWhenMissing x y
   

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

   but mapMaybeMissing uses fewer unnecessary Applicative operations.

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

   ghc-lib-parser	GHC.Data.Word64Map.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"
   

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

   ghc-lib-parser	GHC.Data.Word64Map.Internal

   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.

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

   ghc-lib-parser	GHC.Data.Word64Map.Internal

   Map covariantly over a WhenMatched f x y.

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

   ghc-lib-parser	GHC.Data.Word64Map.Internal

   Map covariantly over a WhenMissing f x.

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

   ghc-lib-parser	GHC.Data.Word64Map.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. mapAccum :: (a -> b -> (a, c)) -> a -> Word64Map b -> (a, Word64Map c)

   ghc-lib-parser	GHC.Data.Word64Map.Lazy

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

9. mapAccumRWithKey :: (a -> Key -> b -> (a, c)) -> a -> Word64Map b -> (a, Word64Map c)

   ghc-lib-parser	GHC.Data.Word64Map.Lazy

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

10. mapAccumWithKey :: (a -> Key -> b -> (a, c)) -> a -> Word64Map b -> (a, Word64Map c)

    ghc-lib-parser	GHC.Data.Word64Map.Lazy

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

Page 219 of many | Previous | Next