Copyright  Conor McBride and Ross Paterson 2005 

License  BSDstyle (see the LICENSE file in the distribution) 
Maintainer  libraries@haskell.org 
Stability  experimental 
Portability  portable 
Safe Haskell  Trustworthy 
Language  Haskell2010 
This module describes a structure intermediate between a functor and
a monad (technically, a strong lax monoidal functor). Compared with
monads, this interface lacks the full power of the binding operation
>>=
, but
 it has more instances.
 it is sufficient for many uses, e.g. contextfree parsing, or the
Traversable
class.  instances can perform analysis of computations before they are executed, and thus produce shared optimizations.
This interface was introduced for parsers by Niklas Röjemo, because it admits more sharing than the monadic interface. The names here are mostly based on parsing work by Doaitse Swierstra.
For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson.
 class Functor f => Applicative f where
 class Applicative f => Alternative f where
 newtype Const a b = Const {
 getConst :: a
 newtype WrappedMonad m a = WrapMonad {
 unwrapMonad :: m a
 newtype WrappedArrow a b c = WrapArrow {
 unwrapArrow :: a b c
 newtype ZipList a = ZipList {
 getZipList :: [a]
 (<$>) :: Functor f => (a > b) > f a > f b
 (<$) :: Functor f => a > f b > f a
 (<**>) :: Applicative f => f a > f (a > b) > f b
 liftA :: Applicative f => (a > b) > f a > f b
 liftA2 :: Applicative f => (a > b > c) > f a > f b > f c
 liftA3 :: Applicative f => (a > b > c > d) > f a > f b > f c > f d
 optional :: Alternative f => f a > f (Maybe a)
Applicative functors
class Functor f => Applicative f where Source
A functor with application, providing operations to
A minimal complete definition must include implementations of these functions satisfying 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
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor
instance for f
will satisfy
If f
is also a Monad
, it should satisfy
(which implies that pure
and <*>
satisfy the applicative functor laws).
Lift a value.
(<*>) :: f (a > b) > f a > f b infixl 4 Source
Sequential application.
(*>) :: f a > f b > f b infixl 4 Source
Sequence actions, discarding the value of the first argument.
(<*) :: f a > f b > f a infixl 4 Source
Sequence actions, discarding the value of the second argument.
Applicative [] Source  
Applicative IO Source  
Applicative Maybe Source  
Applicative ReadP Source  
Applicative ReadPrec Source  
Applicative Last Source  
Applicative First Source  
Applicative STM Source  
Applicative ZipList Source  
Applicative Identity Source  
Applicative ((>) a) Source  
Applicative (Either e) Source  
Monoid a => Applicative ((,) a) Source  
Applicative (ST s) Source  
Applicative (Proxy *) Source  
Arrow a => Applicative (ArrowMonad a) Source  
Monad m => Applicative (WrappedMonad m) Source  
Monoid m => Applicative (Const m) Source  
Applicative (ST s) Source  
Applicative f => Applicative (Alt * f) Source  
Arrow a => Applicative (WrappedArrow a b) Source  
Alternatives
class Applicative f => Alternative f where Source
A monoid on applicative functors.
If defined, some
and many
should be the least solutions
of the equations:
The identity of <>
(<>) :: f a > f a > f a infixl 3 Source
An associative binary operation
One or more.
Zero or more.
Alternative [] Source  
Alternative Maybe Source  
Alternative ReadP Source  
Alternative ReadPrec Source  
Alternative STM Source  
ArrowPlus a => Alternative (ArrowMonad a) Source  
MonadPlus m => Alternative (WrappedMonad m) Source  
Alternative f => Alternative (Alt * f) Source  
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) Source  
Instances
Bifunctor Const Source  
Functor (Const m) Source  
Monoid m => Applicative (Const m) Source  
Foldable (Const m) Source  
Traversable (Const m) Source  
Generic1 (Const a) Source  
Eq a => Eq (Const a b) Source  
Ord a => Ord (Const a b) Source  
Read a => Read (Const a b) Source  
Show a => Show (Const a b) Source  
Generic (Const a b) Source  
Monoid a => Monoid (Const a b) Source  
type Rep1 (Const a) Source  
type Rep (Const a b) Source 
newtype WrappedMonad m a Source
WrapMonad  

Monad m => Monad (WrappedMonad m) Source  
Monad m => Functor (WrappedMonad m) Source  
Monad m => Applicative (WrappedMonad m) Source  
Generic1 (WrappedMonad m) Source  
MonadPlus m => Alternative (WrappedMonad m) Source  
Generic (WrappedMonad m a) Source  
type Rep1 (WrappedMonad m) Source  
type Rep (WrappedMonad m a) Source 
newtype WrappedArrow a b c Source
WrapArrow  

Arrow a => Functor (WrappedArrow a b) Source  
Arrow a => Applicative (WrappedArrow a b) Source  
Generic1 (WrappedArrow a b) Source  
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) Source  
Generic (WrappedArrow a b c) Source  
type Rep1 (WrappedArrow a b) Source  
type Rep (WrappedArrow a b c) Source 
Lists, but with an Applicative
functor based on zipping, so that
f<$>
ZipList
xs1<*>
...<*>
ZipList
xsn =ZipList
(zipWithn f xs1 ... xsn)
ZipList  

Utility functions
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 Source
An infix synonym for fmap
.
Examples
Convert from a
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an Either
Int
Int
Either
Int
String
using show
:
>>>
show <$> Left 17
Left 17>>>
show <$> Right 17
Right "17"
Double each element of a list:
>>>
(*2) <$> [1,2,3]
[2,4,6]
Apply even
to the second element of a pair:
>>>
even <$> (2,2)
(2,True)
(<**>) :: Applicative f => f a > f (a > b) > f b infixl 4 Source
A variant of <*>
with the arguments reversed.
liftA :: Applicative f => (a > b) > f a > f b Source
liftA2 :: Applicative f => (a > b > c) > f a > f b > f c Source
Lift a binary function to actions.
liftA3 :: Applicative f => (a > b > c > d) > f a > f b > f c > f d Source
Lift a ternary function to actions.
optional :: Alternative f => f a > f (Maybe a) Source
One or none.