|
|
|
| Description |
| Utilities related to Monad and Applicative classes
Mostly for backwards compatability.
|
|
| Synopsis |
|
| class Functor f => Applicative f where | | pure :: a -> f a | | (<*>) :: f (a -> b) -> f a -> f b | | (*>) :: f a -> f b -> f b | | (<*) :: f a -> f b -> f a |
| | | (<$>) :: Functor f => (a -> b) -> f a -> f b | | | class Monad m => MonadFix m where | | mfix :: (a -> m a) -> m a |
| | | class Monad m => MonadIO m where | | | | liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b | | | liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c | | | liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d | | | liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e | | | zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d] | | | mapAndUnzipM :: Monad m => (a -> m (b, c)) -> [a] -> m ([b], [c]) | | | mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d]) | | | mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e]) | | | mapAccumLM :: Monad m => (acc -> x -> m (acc, y)) -> acc -> [x] -> m (acc, [y]) | | | mapSndM :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)] | | | concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b] | | | mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] | | | anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool | | | allM :: Monad m => (a -> m Bool) -> [a] -> m Bool | | | foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a | | | foldlM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m () | | | foldrM :: Monad m => (b -> a -> m a) -> a -> [b] -> m a | | | maybeMapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) |
|
|
| Documentation |
|
| class Functor f => Applicative f where |
A functor with application.
Instances should satisfy the following laws:
- identity
-
pure id <*> v = v
- composition
-
pure (.) <*> u <*> v <*> w = u <*> (v <*> w)
- homomorphism
-
pure f <*> pure x = pure (f x)
- interchange
-
u <*> pure y = pure ($ y) <*> u
- ignore left value
-
u *> v = pure (const id) <*> u <*> v
- ignore right value
-
u <* v = pure const <*> u <*> v
The Functor instance should satisfy
fmap f x = pure f <*> x
If f is also a Monad, define pure = return and (<*>) = ap.
Minimal complete definition: pure and <*>.
| | | Methods | | pure :: a -> f a | | Lift a value.
| | | (<*>) :: f (a -> b) -> f a -> f b | | Sequential application.
| | | (*>) :: f a -> f b -> f b | | Sequence actions, discarding the value of the first argument.
| | | (<*) :: f a -> f b -> f a | | Sequence actions, discarding the value of the second argument.
|
| | Instances | |
|
|
| (<$>) :: Functor f => (a -> b) -> f a -> f b |
| An infix synonym for fmap.
|
|
| class Monad m => MonadFix m where |
Monads having fixed points with a 'knot-tying' semantics.
Instances of MonadFix should satisfy the following laws:
- purity
-
mfix (return . h) = return (fix h)
- left shrinking (or tightening)
-
mfix (\x -> a >>= \y -> f x y) = a >>= \y -> mfix (\x -> f x y)
- sliding
-
mfix (Control.Monad.liftM h . f) = Control.Monad.liftM h (mfix (f . h)),
for strict h.
- nesting
-
mfix (\x -> mfix (\y -> f x y)) = mfix (\x -> f x x)
This class is used in the translation of the recursive do notation
supported by GHC and Hugs.
| | | Methods | | mfix :: (a -> m a) -> m a | | The fixed point of a monadic computation.
mfix f executes the action f only once, with the eventual
output fed back as the input. Hence f should not be strict,
for then mfix f would diverge.
|
| | Instances | |
|
|
| class Monad m => MonadIO m where |
| | Methods | | | Instances | |
|
|
| liftIO1 :: MonadIO m => (a -> IO b) -> a -> m b |
| Lift an IO operation with 1 argument into another monad
|
|
| liftIO2 :: MonadIO m => (a -> b -> IO c) -> a -> b -> m c |
| Lift an IO operation with 2 arguments into another monad
|
|
| liftIO3 :: MonadIO m => (a -> b -> c -> IO d) -> a -> b -> c -> m d |
| Lift an IO operation with 3 arguments into another monad
|
|
| liftIO4 :: MonadIO m => (a -> b -> c -> d -> IO e) -> a -> b -> c -> d -> m e |
| Lift an IO operation with 4 arguments into another monad
|
|
| zipWith3M :: Monad m => (a -> b -> c -> m d) -> [a] -> [b] -> [c] -> m [d] |
|
| mapAndUnzipM :: Monad 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.
|
|
| mapAndUnzip3M :: Monad m => (a -> m (b, c, d)) -> [a] -> m ([b], [c], [d]) |
| mapAndUnzipM for triples
|
|
| mapAndUnzip4M :: Monad m => (a -> m (b, c, d, e)) -> [a] -> m ([b], [c], [d], [e]) |
|
| mapAccumLM |
| :: Monad m | | | => (acc -> x -> m (acc, y)) | combining funcction
| | -> acc | initial state
| | -> [x] | inputs
| | -> m (acc, [y]) | final state, outputs
| | Monadic version of mapAccumL
|
|
|
| mapSndM :: Monad m => (b -> m c) -> [(a, b)] -> m [(a, c)] |
| Monadic version of mapSnd
|
|
| concatMapM :: Monad m => (a -> m [b]) -> [a] -> m [b] |
| Monadic version of concatMap
|
|
| mapMaybeM :: Monad m => (a -> m (Maybe b)) -> [a] -> m [b] |
| Monadic version of mapMaybe
|
|
| anyM :: Monad m => (a -> m Bool) -> [a] -> m Bool |
| Monadic version of any, aborts the computation at the first True value
|
|
| allM :: Monad m => (a -> m Bool) -> [a] -> m Bool |
| Monad version of all, aborts the computation at the first False value
|
|
| foldlM :: Monad m => (a -> b -> m a) -> a -> [b] -> m a |
| Monadic version of foldl
|
|
| foldlM_ :: Monad m => (a -> b -> m a) -> a -> [b] -> m () |
| Monadic version of foldl that discards its result
|
|
| foldrM :: Monad m => (b -> a -> m a) -> a -> [b] -> m a |
| Monadic version of foldr
|
|
| maybeMapM :: Monad m => (a -> m b) -> Maybe a -> m (Maybe b) |
| Monadic version of fmap specialised for Maybe
|
|
| Produced by Haddock version 2.7.2 |