| base-3.0.0.0: Basic libraries | Contents | Index

Control.Applicative |

Portability | portable
Stability | experimental
Maintainer | ross@soi.city.ac.uk

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

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
Lift a value.
(<*>) :: f (a -> b) -> f a -> f b
Sequential application.

Instances

Applicative IO
Applicative Id
Applicative Maybe
Applicative ZipList
Applicative []
Monoid m => Applicative (Const m)
Monad m => Applicative (WrappedMonad m)
Monoid a => Applicative ((,) a)
Applicative ((->) a)
Arrow a => Applicative (WrappedArrow a b)

Alternatives
class Applicative f => Alternative f where

A monoid on applicative functors.
Methods

empty :: f a
The identity of `<|>`
(<|>) :: f a -> f a -> f a
An associative binary operation

Instances

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

Instances
newtype Const a b

Constructors

Const |

getConst :: a |

Instances

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

newtype WrappedMonad m a

Constructors

WrapMonad |

unwrapMonad :: (m a) |

Instances

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

newtype WrappedArrow a b c

Constructors

WrapArrow |

unwrapArrow :: (a b c) |

Instances

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

getZipList :: [a] |

Instances

Applicative ZipList
Functor ZipList

Utility functions
(<$>) :: Functor f => (a -> b) -> f a -> f b
A synonym for `fmap`.
(<$) :: Functor f => a -> f b -> f a
Replace the value.
(*>) :: Applicative f => f a -> f b -> f b
Sequence actions, discarding the value of the first argument.
(<*) :: Applicative f => f a -> f b -> f a
Sequence actions, discarding the value of the second argument.
(<**>) :: 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.
some :: Alternative f => f a -> f [a]
One or more.
many :: Alternative f => f a -> f [a]
Zero or more.
Produced by Haddock version 0.8