Hoogle Search

Within LTS Haskell 24.19 (ghc-9.10.3)

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

Exact lookup

1. map' :: (Mapping p, Functor f) => p a b -> p (f a) (f b)

   profunctors	Data.Profunctor.Mapping

   Laws:

   map' . rmap f ≡ rmap (fmap f) . map'
   map' . map' ≡ dimap Compose getCompose . map'
   dimap Identity runIdentity . map' ≡ id
   

2. mapAsWord128 :: ByteArray bs => (Word128 -> Word128) -> bs -> bs

   memory	Data.ByteArray.Mapping

   map blocks of 128 bits of a bytearray, creating a new bytestring of equivalent size where each blocks has been mapped through f no length checking is done. unsafe

3. mapAsWord64 :: ByteArray bs => (Word64 -> Word64) -> bs -> bs

   memory	Data.ByteArray.Mapping

   map blocks of 64 bits of a bytearray, creating a new bytestring of equivalent size where each blocks has been mapped through f no length checking is done. unsafe

4. mapParseError :: Ord e' => (e -> e') -> ParseError s e -> ParseError s e'

   megaparsec	Text.Megaparsec.Error

   Modify the custom data component in a parse error. This could be done via fmap if not for the Ord constraint.

5. mappend :: Monoid a => a -> a -> a

   validity	Data.Validity

   An associative operation NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

6. mappend :: Monoid a => a -> a -> a

   base-compat	Data.Monoid.Compat

   An associative operation NOTE: This method is redundant and has the default implementation mappend = (<>) since base-4.11.0.0. Should it be implemented manually, since mappend is a synonym for (<>), it is expected that the two functions are defined the same way. In a future GHC release mappend will be removed from Monoid.

7. mapAccumM :: (Monad m, Traversable t) => (s -> a -> m (s, b)) -> s -> t a -> m (s, t b)

   base-compat	Data.Traversable.Compat

   The mapAccumM function behaves like a combination of mapM and mapAccumL that traverses the structure while evaluating the actions and passing an accumulating parameter from left to right. It returns a final value of this accumulator together with the new structure. The accumulator is often used for caching the intermediate results of a computation.

   Examples

   Basic usage:

   >>> let expensiveDouble a = putStrLn ("Doubling " <> show a) >> pure (2 * a)
   
   >>> :{
   mapAccumM (\cache a -> case lookup a cache of
   Nothing -> expensiveDouble a >>= \double -> pure ((a, double):cache, double)
   Just double -> pure (cache, double)
   ) [] [1, 2, 3, 1, 2, 3]
   :}
   Doubling 1
   Doubling 2
   Doubling 3
   ([(3,6),(2,4),(1,2)],[2,4,6,2,4,6])
   

8. mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b]

   extra	Control.Monad.Extra

   A version of mapMaybe that works with a monadic predicate.

9. mapLeft :: (a -> c) -> Either a b -> Either c b

   extra	Data.Either.Extra

   The mapLeft function takes a function and applies it to an Either value iff the value takes the form Left _.

   mapLeft show (Left 1) == Left "1"
   mapLeft show (Right True) == Right True
   

10. mapRight :: (b -> c) -> Either a b -> Either a c

    extra	Data.Either.Extra

    The mapRight function takes a function and applies it to an Either value iff the value takes the form Right _.

    mapRight show (Left 1) == Left 1
    mapRight show (Right True) == Right "True"
    

Page 83 of many | Previous | Next