Hoogle Search

Within LTS Haskell 24.28 (ghc-9.10.3)

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

Exact lookup

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

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

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

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

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

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

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

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

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

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

   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) -> Word64Map a -> (Word64Map b, Word64Map c)

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

    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 179 of many | Previous | Next