| base-4.1.0.0: Basic libraries | Source code | Contents | Index

Control.Applicative

Portability | portable
Stability | experimental
Maintainer | libraries@haskell.org

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

class Functor f => Applicative f where

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

class Applicative f => Alternative f where

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

newtype Const a b = Const {

getConst :: a

}

newtype WrappedMonad m a = WrapMonad {

unwrapMonad :: m a

}

newtype WrappedArrow a b c = WrapArrow {

unwrapArrow :: a b c

}

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
optional :: Alternative f => f a -> f (Maybe a)
some :: Alternative f => f a -> f [a]
many :: Alternative f => f a -> f [a]

Applicative functors

class Functor f => Applicative f where | Source

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`

The `Functor` instance should satisfy

          fmap f x = pure f <*> x

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

Methods

pure :: a -> f a | Source

Lift a value.

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

Sequential application.

Instances

Applicative []
Applicative IO
Applicative Maybe
Applicative ZipList
Applicative Id
Applicative ((->) a)
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 | Source

A monoid on applicative functors.
Methods

empty :: f a | Source

The identity of `<|>`

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

An associative binary operation

Instances

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

Instances

newtype Const a b | Source

Constructors

Const |

getConst :: a |

Instances

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

newtype WrappedMonad m a | Source

Constructors

WrapMonad |

unwrapMonad :: m a |

Instances

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

newtype WrappedArrow a b c | Source

Constructors

WrapArrow |

unwrapArrow :: a b c |

Instances

Arrow a => Functor (WrappedArrow a b)
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)
Arrow a => Applicative (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 |

getZipList :: [a] |

Instances

Functor ZipList
Applicative ZipList

Utility functions

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

A synonym for `fmap`.

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

Replace the value.

(*>) :: Applicative f => f a -> f b -> f b | Source

Sequence actions, discarding the value of the first argument.

(<*) :: Applicative f => f a -> f b -> f a | Source

Sequence actions, discarding the value of the second argument.

(<**>) :: 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.

some :: Alternative f => f a -> f [a] | Source

One or more.

many :: Alternative f => f a -> f [a] | Source

Zero or more.
Produced by Haddock version 2.4.2