Portability  portable 

Stability  experimental 
Maintainer  libraries@haskell.org 
This module describes a structure intermediate between a functor and a monad: it provides pure expressions and sequencing, but no binding. (Technically, a strong lax monoidal functor.) For more details, see Applicative Programming with Effects, by Conor McBride and Ross Paterson, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html.
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 recent parsing work by Doaitse Swierstra.
This class is also useful with instances of the
Data.Traversable.Traversable
class.
 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 whereSource
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
Lift a value.
(<*>) :: f (a > b) > f a > f bSource
Sequential application.
(*>) :: f a > f b > f bSource
Sequence actions, discarding the value of the first argument.
(<*) :: f a > f b > f aSource
Sequence actions, discarding the value of the second argument.
Applicative []  
Applicative IO  
Applicative Maybe  
Applicative STM  
Applicative ZipList  
Applicative Id  
Applicative ((>) a)  
Applicative (Either e)  
Monoid a => Applicative ((,) a)  
Monad m => Applicative (WrappedMonad m)  
Monoid m => Applicative (Const m)  
Applicative (StateR s)  
Applicative (StateL s)  
Arrow a => Applicative (WrappedArrow a b) 
Alternatives
class Applicative f => Alternative f whereSource
A monoid on applicative functors.
Minimal complete definition: empty
and <>
.
some
and many
should be the least solutions of the equations:
The identity of <>
(<>) :: f a > f a > f aSource
An associative binary operation
One or more.
Zero or more.
Alternative []  
Alternative Maybe  
Alternative STM  
MonadPlus m => Alternative (WrappedMonad m)  
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) 
Instances
newtype WrappedMonad m a Source
WrapMonad  

Monad m => Functor (WrappedMonad m)  
Monad m => Applicative (WrappedMonad m)  
MonadPlus m => Alternative (WrappedMonad m) 
newtype WrappedArrow a b c Source
WrapArrow  

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

Utility functions
(<**>) :: Applicative f => f a > f (a > b) > f bSource
A variant of <*>
with the arguments reversed.
liftA :: Applicative f => (a > b) > f a > f bSource
liftA2 :: Applicative f => (a > b > c) > f a > f b > f cSource
Lift a binary function to actions.
liftA3 :: Applicative f => (a > b > c > d) > f a > f b > f c > f dSource
Lift a ternary function to actions.
optional :: Alternative f => f a > f (Maybe a)Source
One or none.