protolude-0.1.10: A sensible set of defaults for writing custom Preludes.

Safe Haskell | Trustworthy
Language | Haskell2010

Monad

Synopsis

- class Applicative m => Monad m where
  - (>>=) :: m a -> (a -> m b) -> m b
  - (>>) :: m a -> m b -> m b
  - return :: a -> m a
- class (Alternative m, Monad m) => MonadPlus m where
  - mzero :: m a
  - mplus :: m a -> m a -> m a
- (=<<) :: Monad m => (a -> m b) -> m a -> m b
- (>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c
- (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c
- (>>) :: Monad m => forall a b. m a -> m b -> m b
- forever :: Applicative f => f a -> f b
- join :: Monad m => m (m a) -> m a
- mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a
- filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a]
- mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c])
- zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c]
- zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m ()
- foldM :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m b
- foldM_ :: (Foldable t, Monad m) => (b -> a -> m b) -> b -> t a -> m ()
- replicateM :: Applicative m => Int -> m a -> m [a]
- replicateM_ :: Applicative m => Int -> m a -> m ()
- concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b]
- guard :: Alternative f => Bool -> f ()
- when :: Applicative f => Bool -> f () -> f ()
- unless :: Applicative f => Bool -> f () -> f ()
- liftM :: Monad m => (a1 -> r) -> m a1 -> m r
- liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r
- liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r
- liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r
- liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r
- liftM' :: Monad m => (a -> b) -> m a -> m b
- liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c
- ap :: Monad m => m (a -> b) -> m a -> m b
- (<$!>) :: Monad m => (a -> b) -> m a -> m b

# Documentation

class Applicative m => 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.

Instances of `Monad` should satisfy the following laws:

-     return a >>= k  =  k a

-     m >>= return  =  m

-     m >>= (x -> k x >>= h)  =  (m >>= k) >>= h

Furthermore, the `Monad` and `Applicative` operations should relate as follows:

-     pure = return

-     (<*>) = ap

The above laws imply:

-     fmap f xs  =  xs >>= return . f

-     (>>) = (*>)

and that `pure` and (`<*>`) satisfy the applicative functor laws.

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

Minimal complete definition

(>>=)

Instances

Monad [] |
Methods (>>=) :: [a] -> (a -> [b]) -> [b] # (>>) :: [a] -> [b] -> [b] # return :: a -> [a] # fail :: String -> [a] #
Monad Maybe |
Methods (>>=) :: Maybe a -> (a -> Maybe b) -> Maybe b # (>>) :: Maybe a -> Maybe b -> Maybe b # return :: a -> Maybe a # fail :: String -> Maybe a #
Monad IO |
Methods (>>=) :: IO a -> (a -> IO b) -> IO b # (>>) :: IO a -> IO b -> IO b # return :: a -> IO a # fail :: String -> IO a #
Monad U1 |
Methods (>>=) :: U1 a -> (a -> U1 b) -> U1 b # (>>) :: U1 a -> U1 b -> U1 b # return :: a -> U1 a # fail :: String -> U1 a #
Monad Par1 |
Methods (>>=) :: Par1 a -> (a -> Par1 b) -> Par1 b # (>>) :: Par1 a -> Par1 b -> Par1 b # return :: a -> Par1 a # fail :: String -> Par1 a #
Monad Identity |
Methods (>>=) :: Identity a -> (a -> Identity b) -> Identity b # (>>) :: Identity a -> Identity b -> Identity b # return :: a -> Identity a # fail :: String -> Identity a #
Monad Min |
Methods (>>=) :: Min a -> (a -> Min b) -> Min b # (>>) :: Min a -> Min b -> Min b # return :: a -> Min a # fail :: String -> Min a #
Monad Max |
Methods (>>=) :: Max a -> (a -> Max b) -> Max b # (>>) :: Max a -> Max b -> Max b # return :: a -> Max a # fail :: String -> Max a #
Monad First |
Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Monad Last |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a # fail :: String -> Last a #
Monad Option |
Methods (>>=) :: Option a -> (a -> Option b) -> Option b # (>>) :: Option a -> Option b -> Option b # return :: a -> Option a # fail :: String -> Option a #
Monad NonEmpty |
Methods (>>=) :: NonEmpty a -> (a -> NonEmpty b) -> NonEmpty b # (>>) :: NonEmpty a -> NonEmpty b -> NonEmpty b # return :: a -> NonEmpty a # fail :: String -> NonEmpty a #
Monad Complex |
Methods (>>=) :: Complex a -> (a -> Complex b) -> Complex b # (>>) :: Complex a -> Complex b -> Complex b # return :: a -> Complex a # fail :: String -> Complex a #
Monad STM |
Methods (>>=) :: STM a -> (a -> STM b) -> STM b # (>>) :: STM a -> STM b -> STM b # return :: a -> STM a # fail :: String -> STM a #
Monad Dual |
Methods (>>=) :: Dual a -> (a -> Dual b) -> Dual b # (>>) :: Dual a -> Dual b -> Dual b # return :: a -> Dual a # fail :: String -> Dual a #
Monad Sum |
Methods (>>=) :: Sum a -> (a -> Sum b) -> Sum b # (>>) :: Sum a -> Sum b -> Sum b # return :: a -> Sum a # fail :: String -> Sum a #
Monad Product |
Methods (>>=) :: Product a -> (a -> Product b) -> Product b # (>>) :: Product a -> Product b -> Product b # return :: a -> Product a # fail :: String -> Product a #
Monad First |
Methods (>>=) :: First a -> (a -> First b) -> First b # (>>) :: First a -> First b -> First b # return :: a -> First a # fail :: String -> First a #
Monad Last |
Methods (>>=) :: Last a -> (a -> Last b) -> Last b # (>>) :: Last a -> Last b -> Last b # return :: a -> Last a # fail :: String -> Last a #
Monad Put |
Methods (>>=) :: Put a -> (a -> Put b) -> Put b # (>>) :: Put a -> Put b -> Put b # return :: a -> Put a # fail :: String -> Put a #
Monad Seq |
Methods (>>=) :: Seq a -> (a -> Seq b) -> Seq b # (>>) :: Seq a -> Seq b -> Seq b # return :: a -> Seq a # fail :: String -> Seq a #
Monad ((->) r) |
Methods (>>=) :: (r -> a) -> (a -> r -> b) -> r -> b # (>>) :: (r -> a) -> (r -> b) -> r -> b # return :: a -> r -> a # fail :: String -> r -> a #
Monad (Either e) |
Methods (>>=) :: Either e a -> (a -> Either e b) -> Either e b # (>>) :: Either e a -> Either e b -> Either e b # return :: a -> Either e a # fail :: String -> Either e a #
Monad f => Monad (Rec1 f) |
Methods (>>=) :: Rec1 f a -> (a -> Rec1 f b) -> Rec1 f b # (>>) :: Rec1 f a -> Rec1 f b -> Rec1 f b # return :: a -> Rec1 f a # fail :: String -> Rec1 f a #
Monoid a => Monad ((,) a) |
Methods (>>=) :: (a, a) -> (a -> (a, b)) -> (a, b) # (>>) :: (a, a) -> (a, b) -> (a, b) # return :: a -> (a, a) # fail :: String -> (a, a) #
Monad m => Monad (WrappedMonad m) |
Methods (>>=) :: WrappedMonad m a -> (a -> WrappedMonad m b) -> WrappedMonad m b # (>>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b # return :: a -> WrappedMonad m a # fail :: String -> WrappedMonad m a #
ArrowApply a => Monad (ArrowMonad a) |
Methods (>>=) :: ArrowMonad a a -> (a -> ArrowMonad a b) -> ArrowMonad a b # (>>) :: ArrowMonad a a -> ArrowMonad a b -> ArrowMonad a b # return :: a -> ArrowMonad a a # fail :: String -> ArrowMonad a a #
Monad (Proxy *) |
Methods (>>=) :: Proxy * a -> (a -> Proxy * b) -> Proxy * b # (>>) :: Proxy * a -> Proxy * b -> Proxy * b # return :: a -> Proxy * a # fail :: String -> Proxy * a #
Monad (State s) |
Methods (>>=) :: State s a -> (a -> State s b) -> State s b # (>>) :: State s a -> State s b -> State s b # return :: a -> State s a # fail :: String -> State s a #
Monad m => Monad (ListT m) |
Methods (>>=) :: ListT m a -> (a -> ListT m b) -> ListT m b # (>>) :: ListT m a -> ListT m b -> ListT m b # return :: a -> ListT m a # fail :: String -> ListT m a #
Monad m => Monad (MaybeT m) |
Methods (>>=) :: MaybeT m a -> (a -> MaybeT m b) -> MaybeT m b # (>>) :: MaybeT m a -> MaybeT m b -> MaybeT m b # return :: a -> MaybeT m a # fail :: String -> MaybeT m a #
(Monad f, Monad g) => Monad ((:*:) f g) |
Methods (>>=) :: (f :*: g) a -> (a -> (f :*: g) b) -> (f :*: g) b # (>>) :: (f :*: g) a -> (f :*: g) b -> (f :*: g) b # return :: a -> (f :*: g) a # fail :: String -> (f :*: g) a #
Monad f => Monad (Alt * f) |
Methods (>>=) :: Alt * f a -> (a -> Alt * f b) -> Alt * f b # (>>) :: Alt * f a -> Alt * f b -> Alt * f b # return :: a -> Alt * f a # fail :: String -> Alt * f a #
Monad m => Monad (ExceptT e m) |
Methods (>>=) :: ExceptT e m a -> (a -> ExceptT e m b) -> ExceptT e m b # (>>) :: ExceptT e m a -> ExceptT e m b -> ExceptT e m b # return :: a -> ExceptT e m a # fail :: String -> ExceptT e m a #
(Monad m, Error e) => Monad (ErrorT e m) |
Methods (>>=) :: ErrorT e m a -> (a -> ErrorT e m b) -> ErrorT e m b # (>>) :: ErrorT e m a -> ErrorT e m b -> ErrorT e m b # return :: a -> ErrorT e m a # fail :: String -> ErrorT e m a #
Monad m => Monad (StateT s m) |
Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a # fail :: String -> StateT s m a #
Monad m => Monad (StateT s m) |
Methods (>>=) :: StateT s m a -> (a -> StateT s m b) -> StateT s m b # (>>) :: StateT s m a -> StateT s m b -> StateT s m b # return :: a -> StateT s m a # fail :: String -> StateT s m a #
(Monoid w, Monad m) => Monad (WriterT w m) |
Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a # fail :: String -> WriterT w m a #
(Monoid w, Monad m) => Monad (WriterT w m) |
Methods (>>=) :: WriterT w m a -> (a -> WriterT w m b) -> WriterT w m b # (>>) :: WriterT w m a -> WriterT w m b -> WriterT w m b # return :: a -> WriterT w m a # fail :: String -> WriterT w m a #
Monad m => Monad (IdentityT * m) |
Methods (>>=) :: IdentityT * m a -> (a -> IdentityT * m b) -> IdentityT * m b # (>>) :: IdentityT * m a -> IdentityT * m b -> IdentityT * m b # return :: a -> IdentityT * m a # fail :: String -> IdentityT * m a #
Monad f => Monad (M1 i c f) |
Methods (>>=) :: M1 i c f a -> (a -> M1 i c f b) -> M1 i c f b # (>>) :: M1 i c f a -> M1 i c f b -> M1 i c f b # return :: a -> M1 i c f a # fail :: String -> M1 i c f a #
Monad m => Monad (ReaderT * r m) |
Methods (>>=) :: ReaderT * r m a -> (a -> ReaderT * r m b) -> ReaderT * r m b # (>>) :: ReaderT * r m a -> ReaderT * r m b -> ReaderT * r m b # return :: a -> ReaderT * r m a # fail :: String -> ReaderT * r m a #
(Monoid w, Monad m) => Monad (RWST r w s m) |
Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a # fail :: String -> RWST r w s m a #
(Monoid w, Monad m) => Monad (RWST r w s m) |
Methods (>>=) :: RWST r w s m a -> (a -> RWST r w s m b) -> RWST r w s m b # (>>) :: RWST r w s m a -> RWST r w s m b -> RWST r w s m b # return :: a -> RWST r w s m a # fail :: String -> RWST r w s m a #

class (Alternative m, Monad m) => MonadPlus m where #

Monads that also support choice and failure.

Minimal complete definition

Nothing

Instances

MonadPlus [] |
Methods mzero :: [a] # mplus :: [a] -> [a] -> [a] #
MonadPlus Maybe |
Methods mzero :: Maybe a # mplus :: Maybe a -> Maybe a -> Maybe a #
MonadPlus IO |
Methods mzero :: IO a # mplus :: IO a -> IO a -> IO a #
MonadPlus U1 |
Methods mzero :: U1 a # mplus :: U1 a -> U1 a -> U1 a #
MonadPlus Option |
Methods mzero :: Option a # mplus :: Option a -> Option a -> Option a #
MonadPlus STM |
Methods mzero :: STM a # mplus :: STM a -> STM a -> STM a #
MonadPlus Seq |
Methods mzero :: Seq a # mplus :: Seq a -> Seq a -> Seq a #
MonadPlus f => MonadPlus (Rec1 f) |
Methods mzero :: Rec1 f a # mplus :: Rec1 f a -> Rec1 f a -> Rec1 f a #
(ArrowApply a, ArrowPlus a) => MonadPlus (ArrowMonad a) |
Methods mzero :: ArrowMonad a a # mplus :: ArrowMonad a a -> ArrowMonad a a -> ArrowMonad a a #
MonadPlus (Proxy *) |
Methods mzero :: Proxy * a # mplus :: Proxy * a -> Proxy * a -> Proxy * a #
Monad m => MonadPlus (ListT m) |
Methods mzero :: ListT m a # mplus :: ListT m a -> ListT m a -> ListT m a #
Monad m => MonadPlus (MaybeT m) |
Methods mzero :: MaybeT m a # mplus :: MaybeT m a -> MaybeT m a -> MaybeT m a #
(MonadPlus f, MonadPlus g) => MonadPlus ((:*:) f g) |
Methods mzero :: (f :*: g) a # mplus :: (f :*: g) a -> (f :*: g) a -> (f :*: g) a #
MonadPlus f => MonadPlus (Alt * f) |
Methods mzero :: Alt * f a # mplus :: Alt * f a -> Alt * f a -> Alt * f a #
(Monad m, Monoid e) => MonadPlus (ExceptT e m) |
Methods mzero :: ExceptT e m a # mplus :: ExceptT e m a -> ExceptT e m a -> ExceptT e m a #
(Monad m, Error e) => MonadPlus (ErrorT e m) |
Methods mzero :: ErrorT e m a # mplus :: ErrorT e m a -> ErrorT e m a -> ErrorT e m a #
MonadPlus m => MonadPlus (StateT s m) |
Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
MonadPlus m => MonadPlus (StateT s m) |
Methods mzero :: StateT s m a # mplus :: StateT s m a -> StateT s m a -> StateT s m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
(Monoid w, MonadPlus m) => MonadPlus (WriterT w m) |
Methods mzero :: WriterT w m a # mplus :: WriterT w m a -> WriterT w m a -> WriterT w m a #
MonadPlus m => MonadPlus (IdentityT * m) |
Methods mzero :: IdentityT * m a # mplus :: IdentityT * m a -> IdentityT * m a -> IdentityT * m a #
MonadPlus f => MonadPlus (M1 i c f) |
Methods mzero :: M1 i c f a # mplus :: M1 i c f a -> M1 i c f a -> M1 i c f a #
MonadPlus m => MonadPlus (ReaderT * r m) |
Methods mzero :: ReaderT * r m a # mplus :: ReaderT * r m a -> ReaderT * r m a -> ReaderT * r m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #
(Monoid w, MonadPlus m) => MonadPlus (RWST r w s m) |
Methods mzero :: RWST r w s m a # mplus :: RWST r w s m a -> RWST r w s m a -> RWST r w s m a #

(=<<) :: Monad m => (a -> m b) -> m a -> m b infixr 1 #

Same as `>>=`, but with the arguments interchanged.

(>=>) :: Monad m => (a -> m b) -> (b -> m c) -> a -> m c infixr 1 #

Left-to-right Kleisli composition of monads.

(<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c infixr 1 #

Right-to-left Kleisli composition of monads. `(`>=>`)`, with the arguments flipped.

Note how this operator resembles function composition `(`.`)`:

    (.)   ::            (b ->   c) -> (a ->   b) -> a ->   c
    (<=<) :: Monad m => (b -> m c) -> (a -> m b) -> a -> m c

(>>) :: Monad m => forall a b. m a -> m b -> m b #

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

forever :: Applicative f => f a -> f b #

``forever` act` repeats the action infinitely.

join :: Monad m => m (m a) -> m a #

The `join` function is the conventional monad join operator. It is used to remove one level of monadic structure, projecting its bound argument into the outer level.

mfilter :: MonadPlus m => (a -> Bool) -> m a -> m a #

Direct `MonadPlus` equivalent of `filter` ``filter`` = `(mfilter:: (a -> Bool) -> [a] -> [a]` applicable to any `MonadPlus`, for example `mfilter odd (Just 1) == Just 1` `mfilter odd (Just 2) == Nothing`

filterM :: Applicative m => (a -> m Bool) -> [a] -> m [a] #

This generalizes the list-based `filter` function.

mapAndUnzipM :: Applicative m => (a -> m (b, c)) -> [a] -> m ([b], [c]) #

The `mapAndUnzipM` function maps its first argument over a list, returning the result as a pair of lists. This function is mainly used with complicated data structures or a state-transforming monad.

zipWithM :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m [c] #

The `zipWithM` function generalizes `zipWith` to arbitrary applicative functors.

zipWithM_ :: Applicative m => (a -> b -> m c) -> [a] -> [b] -> m () #

`zipWithM_` is the extension of `zipWithM` which ignores the final result.

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

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 () #

Like `foldM`, but discards the result.

replicateM :: Applicative m => Int -> m a -> m [a] #

``replicateM` n act` performs the action `n` times, gathering the results.

replicateM_ :: Applicative m => Int -> m a -> m () #

Like `replicateM`, but discards the result.

concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b] #

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

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

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

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.

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

The reverse of `when`.

liftM :: Monad m => (a1 -> r) -> m a1 -> m r #

Promote a function to a monad.

liftM2 :: Monad m => (a1 -> a2 -> r) -> m a1 -> m a2 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right. For example,

       liftM2 (+) [0,1] [0,2] = [0,2,1,3]
       liftM2 (+) (Just 1) Nothing = Nothing

liftM3 :: Monad m => (a1 -> a2 -> a3 -> r) -> m a1 -> m a2 -> m a3 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. `liftM2`).

liftM4 :: Monad m => (a1 -> a2 -> a3 -> a4 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. `liftM2`).

liftM5 :: Monad m => (a1 -> a2 -> a3 -> a4 -> a5 -> r) -> m a1 -> m a2 -> m a3 -> m a4 -> m a5 -> m r #

Promote a function to a monad, scanning the monadic arguments from left to right (cf. `liftM2`).

liftM' :: Monad m => (a -> b) -> m a -> m b #

liftM2' :: Monad m => (a -> b -> c) -> m a -> m b -> m c #

ap :: Monad m => m (a -> b) -> m a -> m b #

In many situations, the `liftM` operations can be replaced by uses of `ap`, which promotes function application.

          return f `ap` x1 `ap` ... `ap` xn

is equivalent to

          liftMn f x1 x2 ... xn

(<$!>) :: Monad m => (a -> b) -> m a -> m b #