Monad m => a -> m a

return :: Monad m => a -> m a
base Prelude, base Control.Monad, base Control.Monad.Instances
execStateT :: Monad m => StateT s m a -> s -> m s
transformers Control.Monad.Trans.State.Lazy, transformers Control.Monad.Trans.State.Strict, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final state, discarding the final value. *  m s = liftM snd > (runStateT m  
foldlM :: (Foldable t, Monad m) => (a -> b -> m a) -> a -> t b -> m a
base Data.Foldable
Monadic fold over the elements of a structure, associating to the left, i.e. from left to right.
foldM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a
base Control.Monad
The foldM function is analogous to foldl, except that its result is encapsulated in a monad. Note that foldM works from left-to-right over the list arguments. This could be an issue commutative. > foldM f a1 [x1, x2, ..., xm] == > do > a2 <- f a1 x1 > a3 <- f a2 x2 > ... > f am xm If right-to-left evaluation is required, the input list should be reversed.
foldrM :: (Foldable t, Monad m) => (a -> b -> m b) -> b -> t a -> m b
base Data.Foldable
Monadic fold over the elements of a structure, associating to the right, i.e. from right to left.
gmapM :: (Data a, Monad m) => (forall d. Data d => d -> m d) -> a -> m a
base Data.Data
mkM :: (Monad m, Typeable a, Typeable b) => (b -> m b) -> a -> m a
syb Data.Generics.Aliases
Make a generic monadic transformation; start from a type-specific case; resort to return otherwise
unGM :: GenericM' m -> forall a. Data a => a -> m a
syb Data.Generics.Aliases
polymatchM :: (RegexLike a b, Monad m) => a -> b -> m b
regex-base Text.Regex.Base.Impl
(>>) :: Monad m => m a -> m b -> m b
base Prelude, base Control.Monad, base Control.Monad.Instances
pure :: Applicative f => a -> f a
base Control.Applicative
evalStateT :: Monad m => StateT s m a -> s -> m a
transformers Control.Monad.Trans.State.Lazy, transformers Control.Monad.Trans.State.Strict, mtl Control.Monad.State.Lazy, mtl Control.Monad.State.Strict
Evaluate a state computation with the given initial state and return the final value, discarding the final state. *  m s = liftM fst > (runStateT m  
unQ :: Q a -> forall m. Quasi m => m a
template-haskell Language.Haskell.TH.Syntax
makeRegexM :: (RegexMaker regex compOpt execOpt source, Monad m) => source -> m regex
regex-base Text.Regex.Base.RegexLike
forever :: Monad m => m a -> m b
base Control.Monad
forever act repeats the action infinitely.
getAuth :: Monad m => Request ty -> m URIAuthority
HTTP Network.HTTP.Base
getAuth req fishes out the authority portion of the URL in a request's Host header.
NoArg :: a -> ArgDescr a
base System.Console.GetOpt
no argument expected
Blind :: a -> Blind a
QuickCheck Test.QuickCheck.Modifiers, QuickCheck Test.QuickCheck
single :: a -> BlockTable a
html Text.Html.BlockTable
Consumed :: a -> Consumed a
parsec Text.Parsec.Prim

Show more results