Hoogle Search

Within LTS Haskell 24.6 (ghc-9.10.2)

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

  1. mapMG :: (ModSummary -> ModSummary) -> ModuleGraph -> ModuleGraph

    ghc GHC.Unit.Module.Graph

    Map a function f over all the ModSummaries. To preserve invariants f can't change the isBoot status.

  2. mapMaybe' :: Foldable f => (a -> Maybe b) -> f a -> [b]

    ghc GHC.Utils.Misc

    No documentation available.

  3. mapMaybeM :: Applicative m => (a -> m (Maybe b)) -> [a] -> m [b]

    ghc GHC.Utils.Monad

    Applicative version of mapMaybe

  4. mapMTV :: Monad m => (Name -> m Name) -> (flag -> m flag') -> (Kind -> m Kind) -> TyVarBndr_ flag -> m (TyVarBndr_ flag')

    th-abstraction Language.Haskell.TH.Datatype.TyVarBndr

    Map over the components of a TyVarBndr in a monadic fashion. This is the same as traverseTV, but with a Monad constraint. This is mainly useful for use with old versions of base where Applicative was not a superclass of Monad.

  5. mapMTVFlag :: Monad m => (flag -> m flag') -> TyVarBndr_ flag -> m (TyVarBndr_ flag')

    th-abstraction Language.Haskell.TH.Datatype.TyVarBndr

    Map over the flag of a TyVarBndr in a monadic fashion. This is the same as traverseTVFlag, but with a Monad constraint. This is mainly useful for use with old versions of base where Applicative was not a superclass of Monad.

  6. mapMTVKind :: Monad m => (Kind -> m Kind) -> TyVarBndr_ flag -> m (TyVarBndr_ flag)

    th-abstraction Language.Haskell.TH.Datatype.TyVarBndr

    Map over the Kind of a TyVarBndr in a monadic fashion. This is the same as traverseTVKind, but with a Monad constraint. This is mainly useful for use with old versions of base where Applicative was not a superclass of Monad.

  7. mapMTVName :: Monad m => (Name -> m Name) -> TyVarBndr_ flag -> m (TyVarBndr_ flag)

    th-abstraction Language.Haskell.TH.Datatype.TyVarBndr

    Map over the Name of a TyVarBndr in a monadic fashion. This is the same as traverseTVName, but with a Monad constraint. This is mainly useful for use with old versions of base where Applicative was not a superclass of Monad.

  8. mapM_ :: Monad m => (a -> m ()) -> Consumer' a m r

    pipes Pipes.Prelude

    Consume all values using a monadic function

  9. mapMaybe :: forall (m :: Type -> Type) a b r . Functor m => (a -> Maybe b) -> Pipe a b m r

    pipes Pipes.Prelude

    (mapMaybe f) yields Just results of f. Basic laws: 

    mapMaybe (f >=> g) = mapMaybe f >-> mapMaybe g

mapMaybe (pure @Maybe . f) = mapMaybe (Just . f) = map f

mapMaybe (const Nothing) = drain
    As a result of the second law, 
    mapMaybe return = mapMaybe Just = cat

  10. mapM_ :: (Foldable t, Monad m) => (a -> m b) -> t a -> m ()

    haskell-gi-base Data.GI.Base.ShortPrelude

    Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results. For a version that doesn't ignore the results see mapM. mapM_ is just like traverse_, but specialised to monadic actions.

Page 23 of many | Previous | Next