Portability	portable
Stability	experimental
Maintainer	libraries@haskell.org

Control.Applicative

Contents

Applicative functors
Alternatives
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 Data.Traversable.Traversable class.

Synopsis

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
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

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

Minimal complete definition: pure and <*>.

Methods

pure :: a -> f a

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

Sequence actions, discarding the value of the second argument.

Instances

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 where

A monoid on applicative functors.

Minimal complete definition: empty and <|>.

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

The identity of <|>

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

An associative binary operation

some :: f a -> f [a]

One or more.

many :: f a -> f [a]

Zero or more.

Instances

Alternative []
Alternative Maybe
Alternative STM
MonadPlus m => Alternative (WrappedMonad m)
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

Instances

newtype Const a b

Constructors

Const
Fields getConst :: a

Instances

Functor (Const m)
Monoid m => Applicative (Const m)

newtype WrappedMonad m a

Constructors

WrapMonad
Fields unwrapMonad :: m a

Instances

Monad m => Functor (WrappedMonad m)
Monad m => Applicative (WrappedMonad m)
MonadPlus m => Alternative (WrappedMonad m)

newtype WrappedArrow a b c

Constructors

WrapArrow
Fields unwrapArrow :: a b c

Instances

Arrow a => Functor (WrappedArrow a b)
Arrow a => Applicative (WrappedArrow a b)
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

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
Fields getZipList :: [a]

Instances

Functor ZipList
Applicative ZipList

Utility functions

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

An infix synonym for fmap.

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

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

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.

optional :: Alternative f => f a -> f (Maybe a)

One or none.