base-4.4.1.0: Basic libraries

Control.Applicative

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 Data.Traversable.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, online at http://www.soi.city.ac.uk/~ross/papers/Applicative.html.

Synopsis

# Applicative functors

class Functor f => Applicative f whereSource

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 and (<*>) = ap (which implies that pure and <*> satisfy the applicative functor laws).

Methods

pure :: a -> f aSource

Lift a value.

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

Sequential application.

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

Sequence actions, discarding the value of the first argument.

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

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) Applicative (ST s) Applicative (ST s) 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 whereSource

A monoid on applicative functors.

Minimal complete definition: empty and <|>.

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

Methods

empty :: f aSource

The identity of <|>

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

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 STM MonadPlus m => Alternative (WrappedMonad m) (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)

# Instances

newtype Const a b Source

Constructors

 Const FieldsgetConst :: a

Instances

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

Constructors

Instances

newtype WrappedArrow a b c Source

Constructors

 WrapArrow FieldsunwrapArrow :: 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 Source

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

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

Constructors

 ZipList FieldsgetZipList :: [a]

Instances

 Functor ZipList Applicative ZipList

# Utility functions

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

An infix synonym for fmap.

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

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 bSource

A variant of <*> with the arguments reversed.

liftA :: Applicative f => (a -> b) -> f a -> f bSource

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 cSource

Lift a binary function to actions.

liftA3 :: Applicative f => (a -> b -> c -> d) -> f a -> f b -> f c -> f dSource

Lift a ternary function to actions.

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

One or none.