base-compat-0.8.0.1: A compatibility layer for base

Safe Haskell Safe-Inferred Haskell98

Control.Monad.Compat

Synopsis

# Documentation

class Monad m where

The `Monad` class defines the basic operations over a monad, a concept from a branch of mathematics known as category theory. From the perspective of a Haskell programmer, however, it is best to think of a monad as an abstract datatype of actions. Haskell's `do` expressions provide a convenient syntax for writing monadic expressions.

Minimal complete definition: `>>=` and `return`.

Instances of `Monad` should satisfy the following laws:

```return a >>= k  ==  k a
m >>= return  ==  m
m >>= (\x -> k x >>= h)  ==  (m >>= k) >>= h```

Instances of both `Monad` and `Functor` should additionally satisfy the law:

`fmap f xs  ==  xs >>= return . f`

The instances of `Monad` for lists, `Maybe` and `IO` defined in the Prelude satisfy these laws.

Minimal complete definition

Methods

(>>=) :: m a -> (a -> m b) -> m b infixl 1

Sequentially compose two actions, passing any value produced by the first as an argument to the second.

(>>) :: m a -> m b -> m b infixl 1

Sequentially compose two actions, discarding any value produced by the first, like sequencing operators (such as the semicolon) in imperative languages.

return :: a -> m a

Inject a value into the monadic type.

fail :: String -> m a

Fail with a message. This operation is not part of the mathematical definition of a monad, but is invoked on pattern-match failure in a `do` expression.

Instances

 Monad [] Monad IO Monad P Monad ReadPrec Monad ReadP Monad Maybe Monad ((->) r) Monad (Either e) Monad m => Monad (WrappedMonad m)

class Monad m => MonadPlus m where

Monads that also support choice and failure.

Methods

mzero :: m a

the identity of `mplus`. It should also satisfy the equations

```mzero >>= f  =  mzero
v >> mzero   =  mzero```

mplus :: m a -> m a -> m a

an associative operation

Instances

 MonadPlus [] MonadPlus P MonadPlus ReadPrec MonadPlus ReadP MonadPlus Maybe

foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b Source

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 where `(>>)` and the `folded function' are not 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.

Note: `foldM` is the same as `foldlM`

foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m () Source

Like `foldM`, but discards the result.

forM :: (Traversable t, Monad m) => t a -> (a -> m b) -> m (t b)

`forM` is `mapM` with its arguments flipped.

forM_ :: (Foldable t, Monad m) => t a -> (a -> m b) -> m ()

`forM_` is `mapM_` with its arguments flipped.

guard :: Alternative f => Bool -> f () Source

`guard b` is `pure ()` if `b` is `True`, and `empty` if `b` is `False`.

mapM :: Traversable t => forall a m b. Monad m => (a -> m b) -> t a -> m (t b)

Map each element of a structure to a monadic action, evaluate these actions from left to right, and collect the results.

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

Map each element of a structure to a monadic action, evaluate these actions from left to right, and ignore the results.

msum :: (Foldable t, MonadPlus m) => t (m a) -> m a

The sum of a collection of actions, generalizing `concat`.

sequence :: Traversable t => forall m a. Monad m => t (m a) -> m (t a)

Evaluate each monadic action in the structure from left to right, and collect the results.

sequence_ :: (Foldable t, Monad m) => t (m a) -> m ()

Evaluate each monadic action in the structure from left to right, and ignore the results.

unless :: Applicative f => Bool -> f () -> f () Source

The reverse of `when`.

when :: Applicative f => Bool -> f () -> f () Source

Conditional execution of `Applicative` expressions. For example,

`when debug (putStrLn "Debugging")`

will output the string `Debugging` if the Boolean value `debug` is `True`, and otherwise do nothing.

(<\$!>) :: Monad m => (a -> b) -> m a -> m b infixl 4 Source

Strict version of `<\$>`.

Since: 4.8.0.0