Control.Applicative
 Portability portable Stability experimental Maintainer ross@soi.city.ac.uk
 Contents Applicative functors Instances Utility functions
Description

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 Traversable class.

Synopsis
class Functor f => Applicative f where
 pure :: a -> f a (<*>) :: f (a -> b) -> f a -> f b
newtype WrappedMonad m a = WrapMonad {
 unwrapMonad :: (m a)
}
newtype Const a b = Const {
 getConst :: a
}
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 b -> f b
(<*) :: Applicative f => 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
Applicative functors
class Functor f => Applicative f where

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

If f is also a Monad, define pure = return and (<*>) = ap.

Methods
 pure :: a -> f a Lift a value. (<*>) :: f (a -> b) -> f a -> f b Sequential application.
Instances
 Applicative IO Applicative Id Applicative Maybe Applicative ZipList Applicative [] Monoid m => Applicative (Const m) Monad m => Applicative (WrappedMonad m) Monoid a => Applicative ((,) a) Applicative ((->) a)
Instances
newtype WrappedMonad m a
Constructors
WrapMonad
 unwrapMonad :: (m a)
Instances
 Monad m => Applicative (WrappedMonad m) Monad m => Functor (WrappedMonad m)
newtype Const a b
Constructors
Const
 getConst :: a
Instances
 Monoid m => Applicative (Const m) Functor (Const m)
newtype ZipList a

Lists, but with an Applicative functor based on zipping, so that

`f <\$> ZipList xs1 <*> ... <*> ZipList xsn = ZipList (zipWithn f xs1 ... xsn)`
Constructors
ZipList
 getZipList :: [a]
Instances
 Applicative ZipList Functor ZipList
Utility functions
(<\$>) :: Functor f => (a -> b) -> f a -> f b
A synonym for fmap.
(<\$) :: Functor f => a -> f b -> f a
Replace the value.
(*>) :: Applicative f => f a -> f b -> f b
Sequence actions, discarding the value of the first argument.
(<*) :: Applicative f => f a -> f b -> f a
Sequence actions, discarding the value of the second argument.
(<**>) :: Applicative f => f a -> f (a -> b) -> f b
A variant of <*> with the arguments reversed.
liftA :: Applicative f => (a -> b) -> f a -> f b
Lift a function to actions. This function may be used as a value for fmap in a Functor instance.
liftA2 :: Applicative f => (a -> b -> c) -> f a -> f b -> f c
Lift a binary function to actions.
liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f d
Lift a ternary function to actions.
Produced by Haddock version 0.7