Hoogle Search

Within LTS Haskell 24.33 (ghc-9.10.3)

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

Exact lookup

1. mapAccumL :: (a -> Char -> (a, Char)) -> a -> Stream Char -> (a, Text)

   text	Data.Text.Internal.Fusion

   O(n) Like a combination of map and foldl'. Applies a function to each element of a Text, passing an accumulating parameter from left to right, and returns a final Text. Properties

   mapAccumL g z0 . stream = mapAccumL g z0
   

2. mapAccumL :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

   text	Data.Text.Lazy

   O(n) Like a combination of map and foldl'. Applies a function to each element of a Text, passing an accumulating parameter from left to right, and returns a final Text. Performs replacement on invalid scalar values.

3. mapAccumR :: (a -> Char -> (a, Char)) -> a -> Text -> (a, Text)

   text	Data.Text.Lazy

   The mapAccumR function behaves like a combination of map and a strict foldr; it applies a function to each element of a Text, passing an accumulating parameter from right to left, and returning a final value of this accumulator together with the new Text. Performs replacement on invalid scalar values.

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

   containers	Data.IntMap.Internal

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

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

   containers	Data.IntMap.Internal

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

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

   containers	Data.IntMap.Internal

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

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

   containers	Data.IntMap.Internal

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

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

   containers	Data.IntMap.Internal

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

9. mapGentlyWhenMatched :: 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.Internal

   Map covariantly over a WhenMatched f k x, using only a 'Functor f' constraint.

10. mapGentlyWhenMissing :: forall (f :: Type -> Type) a b x . Functor f => (a -> b) -> WhenMissing f x a -> WhenMissing f x b

    containers	Data.IntMap.Internal

    Map covariantly over a WhenMissing f x, using only a 'Functor f' constraint.

Page 51 of many | Previous | Next