Applicative package:base

class Functor f => Applicative (f :: Type -> Type)

base Prelude Control.Applicative GHC.Base

A functor with application, providing operations to

embed pure expressions (pure), and
sequence computations and combine their results (<*> 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:

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 = (id <$ u)
<*> v
```
```
u <* v = liftA2 const u v
```

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

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

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

```
pure = return
```

m1 <*> m2 = m1 >>= (\x1 -> m2
>>= (\x2 -> return (x1 x2)))

```
(*>) = (>>)
```

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

module Control.Applicative

base

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.