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
Traversable
class.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 Source
A functor with application, providing operations to
pure
), and<*>
and liftA2
).A minimal complete definition must include implementations of pure
and of either <*>
or liftA2
. If it defines both, then they must behave the same as their default definitions:
(<*>) = liftA2 id
liftA2 f x y = f <$> x <*> y
Further, any definition must satisfy the following:
pure
id
<*>
v = v
pure
(.)<*>
u<*>
v<*>
w = u<*>
(v<*>
w)
pure
f<*>
pure
x =pure
(f x)
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
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2
p (liftA2
q u v) =liftA2
f u .liftA2
g v
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.
A few functors support an implementation of <*>
that is more efficient than the default one.
liftA2 :: (a > b > c) > f a > f b > f c Source
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more efficient than the default one. In particular, if fmap
is an expensive operation, it is likely better to use liftA2
than to fmap
over the structure and then use <*>
.
(*>) :: 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 []  Since: 2.1 
Applicative Maybe  Since: 2.1 
Applicative IO  Since: 2.1 
Applicative Par1  Since: 4.9.0.0 
Applicative ReadP  Since: 4.6.0.0 
Applicative ReadPrec  Since: 4.6.0.0 
Applicative Last  
Applicative First  
Applicative Product  Since: 4.8.0.0 
Applicative Sum  Since: 4.8.0.0 
Applicative Dual  Since: 4.8.0.0 
Applicative STM  Since: 4.8.0.0 
Applicative Identity  Since: 4.8.0.0 
Applicative ZipList 
f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN ZipList (zipWithN f xs1 ... xsN)where (\a b c > stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c > stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: 2.1 
Applicative NonEmpty  Since: 4.9.0.0 
Applicative Option  Since: 4.9.0.0 
Applicative Last  Since: 4.9.0.0 
Applicative First  Since: 4.9.0.0 
Applicative Max  Since: 4.9.0.0 
Applicative Min  Since: 4.9.0.0 
Applicative Complex  Since: 4.9.0.0 
Applicative (Either e)  Since: 3.0 
Applicative (U1 *)  Since: 4.9.0.0 
Monoid a => Applicative ((,) a) 
For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: 2.1 
Applicative (ST s)  Since: 4.4.0.0 
Applicative (Proxy *)  Since: 4.7.0.0 
Arrow a => Applicative (ArrowMonad a)  Since: 4.6.0.0 
Monad m => Applicative (WrappedMonad m)  Since: 2.1 
Applicative (ST s)  Since: 2.1 
Applicative f => Applicative (Rec1 * f)  Since: 4.9.0.0 
Applicative f => Applicative (Alt * f)  
Monoid m => Applicative (Const * m)  Since: 2.0.1 
Arrow a => Applicative (WrappedArrow a b)  Since: 2.1 
Applicative ((>) LiftedRep LiftedRep a)  Since: 2.1 
(Applicative f, Applicative g) => Applicative ((:*:) * f g)  Since: 4.9.0.0 
(Applicative f, Applicative g) => Applicative (Product * f g)  Since: 4.9.0.0 
Applicative f => Applicative (M1 * i c f)  Since: 4.9.0.0 
(Applicative f, Applicative g) => Applicative ((:.:) * * f g)  Since: 4.9.0.0 
(Applicative f, Applicative g) => Applicative (Compose * * f g)  Since: 4.9.0.0 
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 []  Since: 2.1 
Alternative Maybe  Since: 2.1 
Alternative IO  Since: 4.9.0.0 
Alternative ReadP  Since: 4.6.0.0 
Alternative ReadPrec  Since: 4.6.0.0 
Alternative STM  Since: 4.8.0.0 
Alternative Option  Since: 4.9.0.0 
Alternative (U1 *)  Since: 4.9.0.0 
Alternative (Proxy *)  Since: 4.9.0.0 
ArrowPlus a => Alternative (ArrowMonad a)  Since: 4.6.0.0 
MonadPlus m => Alternative (WrappedMonad m)  Since: 2.1 
Alternative f => Alternative (Rec1 * f)  Since: 4.9.0.0 
Alternative f => Alternative (Alt * f)  
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)  Since: 2.1 
(Alternative f, Alternative g) => Alternative ((:*:) * f g)  Since: 4.9.0.0 
(Alternative f, Alternative g) => Alternative (Product * f g)  Since: 4.9.0.0 
Alternative f => Alternative (M1 * i c f)  Since: 4.9.0.0 
(Alternative f, Applicative g) => Alternative ((:.:) * * f g)  Since: 4.9.0.0 
(Alternative f, Applicative g) => Alternative (Compose * * f g)  Since: 4.9.0.0 
The Const
functor.
Generic1 k (Const k a)  
Show2 (Const *)  Since: 4.9.0.0 
Read2 (Const *)  Since: 4.9.0.0 
Ord2 (Const *)  Since: 4.9.0.0 
Eq2 (Const *)  Since: 4.9.0.0 
Bifunctor (Const *)  Since: 4.8.0.0 
Bifoldable (Const *)  Since: 4.10.0.0 
Bitraversable (Const *)  Since: 4.10.0.0 
Functor (Const * m)  Since: 2.1 
Monoid m => Applicative (Const * m)  Since: 2.0.1 
Foldable (Const * m)  Since: 4.7.0.0 
Traversable (Const * m)  Since: 4.7.0.0 
Show a => Show1 (Const * a)  Since: 4.9.0.0 
Read a => Read1 (Const * a)  Since: 4.9.0.0 
Ord a => Ord1 (Const * a)  Since: 4.9.0.0 
Eq a => Eq1 (Const * a)  Since: 4.9.0.0 
Bounded a => Bounded (Const k a b)  
Enum a => Enum (Const k a b)  
Eq a => Eq (Const k a b)  
Floating a => Floating (Const k a b)  
Fractional a => Fractional (Const k a b)  
Integral a => Integral (Const k a b)  
(Typeable * k3, Data a, Typeable k3 b) => Data (Const k3 a b)  Since: 4.10.0.0 
Num a => Num (Const k a b)  
Ord a => Ord (Const k a b)  
Read a => Read (Const k a b) 
This instance would be equivalent to the derived instances of the Since: 4.8.0.0 
Real a => Real (Const k a b)  
RealFloat a => RealFloat (Const k a b)  
RealFrac a => RealFrac (Const k a b)  
Show a => Show (Const k a b) 
This instance would be equivalent to the derived instances of the Since: 4.8.0.0 
Ix a => Ix (Const k a b)  
IsString a => IsString (Const * a b)  Since: 4.9.0.0 
Generic (Const k a b)  
Semigroup a => Semigroup (Const k a b)  Since: 4.9.0.0 
Monoid a => Monoid (Const k a b)  
FiniteBits a => FiniteBits (Const k a b)  
Bits a => Bits (Const k a b)  
Storable a => Storable (Const k a b)  
type Rep1 k (Const k a)  
type Rep (Const k a b)  
newtype WrappedMonad m a Source
WrapMonad  
Fields

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

Generic1 * (WrappedArrow a b)  
Arrow a => Functor (WrappedArrow a b)  Since: 2.1 
Arrow a => Applicative (WrappedArrow a b)  Since: 2.1 
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)  Since: 2.1 
Generic (WrappedArrow a b c)  
type Rep1 * (WrappedArrow a b)  
type Rep (WrappedArrow a b c)  
Lists, but with an Applicative
functor based on zipping.
ZipList  
Fields

Functor ZipList  
Applicative ZipList 
f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN ZipList (zipWithN f xs1 ... xsN)where (\a b c > stimes c [a, b]) <$> ZipList "abcd" <*> ZipList "567" <*> ZipList [1..] = ZipList (zipWith3 (\a b c > stimes c [a, b]) "abcd" "567" [1..]) = ZipList {getZipList = ["a5","b6b6","c7c7c7"]} Since: 2.1 
Foldable ZipList  
Traversable ZipList  Since: 4.9.0.0 
Eq a => Eq (ZipList a)  
Ord a => Ord (ZipList a)  
Read a => Read (ZipList a)  
Show a => Show (ZipList a)  
Generic (ZipList a)  
Generic1 * ZipList  
type Rep (ZipList a)  
type Rep1 * ZipList  
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 Source
An infix synonym for fmap
.
The name of this operator is an allusion to $
. Note the similarities between their types:
($) :: (a > b) > a > b (<$>) :: Functor f => (a > b) > f a > f b
Whereas $
is function application, <$>
is function application lifted over a Functor
.
Convert from a Maybe Int
to a Maybe String
using show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an Either Int Int
to an 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)
(<$) :: Functor f => a > f b > f a infixl 4 Source
Replace all locations in the input with the same value. The default definition is fmap . const
, but this may be overridden with a more efficient version.
(<**>) :: 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
Lift a function to actions. This function may be used as a value for fmap
in a Functor
instance.
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.
© The University of Glasgow and others
Licensed under a BSDstyle license (see top of the page).
https://downloads.haskell.org/~ghc/8.2.1/docs/html/libraries/base4.10.0.0/ControlApplicative.html