| base-3.0.2.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 `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 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 | 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 Maybe
Alternative []
MonadPlus m => Alternative (WrappedMonad m)
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b)
Instances
newtype Const a b | Source
Constructors
Const |
getConst :: a |
Instances
Monoid m => Applicative (Const m)
Functor (Const m)
newtype WrappedMonad m a | Source
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 | Source
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 | 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
Applicative ZipList
Functor 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 0.9