Haskell Hierarchical Libraries (base package)ContentsIndex
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 (Const m)
Monad m => Functor (WrappedMonad m)
Arrow a => Functor (WrappedArrow a b)
Functor ZipList
Functor ((->) r)
Functor ((,) a)
Functor (Either a)
Functor (ST s)
Functor IntMap
Functor (Map k)
Functor Maybe
Functor Queue
Functor Seq
Functor FingerTree
Functor Digit
Functor Node
Functor Elem
Functor ViewL
Functor ViewR
Functor Id
Functor Tree
Ix i => Functor (Array i)
Functor []
Functor STM
Functor IO
Functor (ST s)
Functor ReadP
Functor ReadPrec
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
ArrowApply a => Monad (ArrowMonad a)
Monad ((->) r)
Monad (ST s)
Monad Maybe
Monad Seq
Monad []
Monad STM
Monad IO
Monad (ST s)
Monad P
Monad ReadP
Monad ReadPrec
Produced by Haddock version 0.6