| Haskell Hierarchical Libraries (base package) | Source code | Contents | Index

Control.Monad.Instances |

Portability | portable
Stability | provisional
Maintainer | libraries@haskell.org

Description
`Functor` and `Monad` instances for `(->) r` and `Functor` instances for `(,) a` and ``Either` a`.
Synopsis

class Functor f where

fmap :: (a -> b) -> f a -> f b

class Monad m where

(>>=) :: forall a b . m a -> (a -> m b) -> m b
(>>) :: forall a b . m a -> m b -> m b
return :: a -> m a
fail :: String -> m a

Documentation
class Functor f where

The `Functor` class is used for types that can be mapped over. Instances of `Functor` should satisfy the following laws:
     fmap id  ==  id
     fmap (f . g)  ==  fmap f . fmap g
The instances of `Functor` for lists, `Maybe` and `IO` defined in the Prelude satisfy these laws.
Methods

fmap :: (a -> b) -> f a -> f b

Instances

Functor Digit
Functor Elem
Functor FingerTree
Functor IO
Functor Id
Functor IntMap
Functor Maybe
Functor Node
Functor Queue
Functor ReadP
Functor ReadPrec
Functor STM
Functor Seq
Functor Tree
Functor ViewL
Functor ViewR
Functor ZipList
Functor []
Ix i => Functor (Array i)
Functor (Const m)
Functor (Either a)
Functor (Map k)
Functor (ST s)
Functor (ST s)
Monad m => Functor (WrappedMonad m)
Functor ((,) a)
Functor ((->) r)
Arrow a => Functor (WrappedArrow a b)

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.

Methods

(>>=) :: forall a b . m a -> (a -> m b) -> m b
Sequentially compose two actions, passing any value produced by the first as an argument to the second.
(>>) :: 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.
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 IO
Monad Maybe
Monad P
Monad ReadP
Monad ReadPrec
Monad STM
Monad Seq
Monad []
ArrowApply a => Monad (ArrowMonad a)
Monad (ST s)
Monad (ST s)
Monad ((->) r)

Produced by Haddock version 0.8