Copyright	Conor McBride and Ross Paterson 2005
License	BSD-style (see the LICENSE file in the distribution)
Maintainer	libraries@haskell.org
Stability	experimental
Portability	portable
Safe Haskell	Trustworthy
Language	Haskell2010

Control.Applicative

Contents

Applicative functors
Alternatives
Instances
Utility functions

Description

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. context-free 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.

Synopsis

Applicative functors

class Functor f => Applicative f where Source

A functor with application, providing operations to

embed pure expressions (pure), and
sequence computations and combine their results (<*>).

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:

```
u *> v = pure (const id) <*> u <*> v
```
```
u <* v = pure const <*> u <*> v
```

As a consequence of these laws, the Functor instance for f will satisfy

```
fmap f x = pure f <*> x
```

If f is also a Monad, it should satisfy

```
pure = return
```
```
(<*>) = ap
```

(which implies that pure and <*> satisfy the applicative functor laws).

Methods

pure :: a -> f a Source

Lift a value.

(<*>) :: f (a -> b) -> f a -> f b Source

Sequential application.

(*>) :: f a -> f b -> f b Source

Sequence actions, discarding the value of the first argument.

(<*) :: f a -> f b -> f a Source

Sequence actions, discarding the value of the second argument.

Instances

Applicative []
Applicative IO
Applicative Maybe
Applicative ReadP
Applicative ReadPrec
Applicative STM
Applicative ZipList
Applicative ((->) a)
Applicative (Either e)
Monoid a => Applicative ((,) a)
Applicative (ST s)
Applicative (Proxy *)
Arrow a => Applicative (ArrowMonad a)
Applicative (ST s)
Monad m => Applicative (WrappedMonad m)
Monoid m => Applicative (Const m)
Arrow a => Applicative (WrappedArrow a b)
Typeable ((* -> *) -> Constraint) Applicative

Alternatives

class Applicative f => Alternative f where Source

A monoid on applicative functors.

Minimal complete definition: empty and <|>.

If defined, some and many should be the least solutions of the equations:

```
some v = (:) <$> v <*> many v
```
```
many v = some v <|> pure []
```

Methods

empty :: f a Source

The identity of <|>

(<|>) :: f a -> f a -> f a Source

An associative binary operation

some :: f a -> f [a] Source

One or more.

many :: f a -> f [a] Source

Zero or more.

Instances

Alternative []
Alternative Maybe
Alternative ReadP
Alternative ReadPrec
Alternative STM
ArrowPlus a => Alternative (ArrowMonad a)
MonadPlus m => Alternative (WrappedMonad m)
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)
Typeable ((* -> *) -> Constraint) Alternative

Instances

newtype Const a b Source

Constructors

Const
Fields getConst :: a

Instances

Functor (Const m)
Monoid m => Applicative (Const m)
Foldable (Const m)
Traversable (Const m)
Generic1 (Const a)
Generic (Const a b)
Monoid a => Monoid (Const a b)
type Rep1 (Const a) = D1 D1Const (C1 C1_0Const (S1 S1_0_0Const (Rec0 a)))
type Rep (Const a b) = D1 D1Const (C1 C1_0Const (S1 S1_0_0Const (Rec0 a)))

newtype WrappedMonad m a Source

Constructors

WrapMonad
Fields unwrapMonad :: m a

Instances

MonadPlus m => Alternative (WrappedMonad m)
Monad m => Monad (WrappedMonad m)
Monad m => Functor (WrappedMonad m)
Monad m => Applicative (WrappedMonad m)
Generic1 (WrappedMonad m)
Generic (WrappedMonad m a)
type Rep1 (WrappedMonad m) = D1 D1WrappedMonad (C1 C1_0WrappedMonad (S1 S1_0_0WrappedMonad (Rec1 m)))
type Rep (WrappedMonad m a) = D1 D1WrappedMonad (C1 C1_0WrappedMonad (S1 S1_0_0WrappedMonad (Rec0 (m a))))

newtype WrappedArrow a b c Source

Constructors

WrapArrow
Fields unwrapArrow :: a b c

Instances

(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)
Arrow a => Functor (WrappedArrow a b)
Arrow a => Applicative (WrappedArrow a b)
Generic1 (WrappedArrow a b)
Generic (WrappedArrow a b c)
type Rep1 (WrappedArrow a b) = D1 D1WrappedArrow (C1 C1_0WrappedArrow (S1 S1_0_0WrappedArrow (Rec1 (a b))))
type Rep (WrappedArrow a b c) = D1 D1WrappedArrow (C1 C1_0WrappedArrow (S1 S1_0_0WrappedArrow (Rec0 (a b c))))

newtype ZipList a Source

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

f <$> ZipList xs1 <*> ... <*> ZipList xsn = ZipList (zipWithn f xs1 ... xsn)

Constructors

ZipList
Fields getZipList :: [a]

Instances

Functor ZipList
Applicative ZipList
Generic1 ZipList
Eq a => Eq (ZipList a)
Ord a => Ord (ZipList a)
Read a => Read (ZipList a)
Show a => Show (ZipList a)
Generic (ZipList a)
type Rep1 ZipList = D1 D1ZipList (C1 C1_0ZipList (S1 S1_0_0ZipList (Rec1 [])))
type Rep (ZipList a) = D1 D1ZipList (C1 C1_0ZipList (S1 S1_0_0ZipList (Rec0 [a])))

Utility functions

(<$>) :: Functor f => (a -> b) -> f a -> f b Source

An infix synonym for fmap.

(<$) :: Functor f => a -> f b -> f a 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 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.

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.