Control.Applicative
Control.Applicative
| Copyright | Conor McBride and Ross Paterson 2005 |
|---|---|
| License | BSD-style (see the LICENSE file in the distribution) |
| Maintainer | libraries@haskell.org |
| Stability | experimental |
| Portability | portable |
| Safe Haskell | Trustworthy |
| Language | Haskell2010 |
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
Traversableclass. - 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.
Applicative functors
class Functor f => Applicative f where Source
A functor with application, providing operations to
A minimal complete definition must include implementations of these functions satisfying the following laws:
- identity
pureid<*>v = v- composition
pure(.)<*>u<*>v<*>w = u<*>(v<*>w)- homomorphism
puref<*>purex =pure(f x)- interchange
u
<*>purey =pure($y)<*>u
The other methods have the following default definitions, which may be overridden with equivalent specialized implementations:
As a consequence of these laws, the Functor instance for f will satisfy
If f is also a Monad, it should satisfy
(which implies that pure and <*> satisfy the applicative functor laws).
Methods
Lift a value.
(<*>) :: f (a -> b) -> f a -> f b infixl 4 Source
Sequential application.
(*>) :: f a -> f b -> f b infixl 4 Source
Sequence actions, discarding the value of the first argument.
(<*) :: f a -> f b -> f a infixl 4 Source
Sequence actions, discarding the value of the second argument.
Instances
Alternatives
class Applicative f => Alternative f where Source
A monoid on applicative functors.
If defined, some and many should be the least solutions of the equations:
Methods
The identity of <|>
(<|>) :: f a -> f a -> f a infixl 3 Source
An associative binary operation
One or more.
Zero or more.
Instances
| Alternative [] | |
| Alternative Maybe | |
| Alternative IO | |
| Alternative U1 | |
| Alternative ReadP | |
| Alternative ReadPrec | |
| Alternative STM | |
| Alternative Option | |
| Alternative f => Alternative (Rec1 f) | |
| Alternative (Proxy *) | |
| ArrowPlus a => Alternative (ArrowMonad a) | |
| MonadPlus m => Alternative (WrappedMonad m) | |
| (Alternative f, Alternative g) => Alternative ((:*:) f g) | |
| (Alternative f, Applicative g) => Alternative ((:.:) f g) | |
| Alternative f => Alternative (Alt * f) | |
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
| Alternative f => Alternative (M1 i c f) | |
| (Alternative f, Alternative g) => Alternative (Product * f g) | |
| (Alternative f, Applicative g) => Alternative (Compose * * f g) | |
Instances
The Const functor.
Instances
| Bifunctor (Const *) | |
| Show2 (Const *) | |
| Read2 (Const *) | |
| Ord2 (Const *) | |
| Eq2 (Const *) | |
| Functor (Const * m) | |
| Monoid m => Applicative (Const * m) | |
| Foldable (Const * m) | |
| Traversable (Const * m) | |
| Generic1 (Const * a) | |
| Show a => Show1 (Const * a) | |
| Read a => Read1 (Const * a) | |
| Ord a => Ord1 (Const * a) | |
| Eq a => Eq1 (Const * a) | |
| Bounded a => Bounded (Const k a b) | |
| Enum a => Enum (Const k a b) | |
| Eq a => Eq (Const k a b) | |
| Floating a => Floating (Const k a b) | |
| Fractional a => Fractional (Const k a b) | |
| Integral a => Integral (Const k a b) | |
| Num a => Num (Const k a b) | |
| Ord a => Ord (Const k a b) | |
| Read a => Read (Const k a b) | This instance would be equivalent to the derived instances of the |
| Real a => Real (Const k a b) | |
| RealFloat a => RealFloat (Const k a b) | |
| RealFrac a => RealFrac (Const k a b) | |
| Show a => Show (Const k a b) | This instance would be equivalent to the derived instances of the |
| Ix a => Ix (Const k a b) | |
| IsString a => IsString (Const * a b) | |
| Generic (Const k a b) | |
| Semigroup a => Semigroup (Const k a b) | |
| Monoid a => Monoid (Const k a b) | |
| FiniteBits a => FiniteBits (Const k a b) | |
| Bits a => Bits (Const k a b) | |
| Storable a => Storable (Const k a b) | |
| type Rep1 (Const * a) | |
| type Rep (Const k a b) | |
newtype WrappedMonad m a Source
Constructors
| WrapMonad | |
Fields
| |
Instances
| Monad m => Monad (WrappedMonad m) | |
| Monad m => Functor (WrappedMonad m) | |
| Monad m => Applicative (WrappedMonad m) | |
| Generic1 (WrappedMonad m) | |
| MonadPlus m => Alternative (WrappedMonad m) | |
| Generic (WrappedMonad m a) | |
| type Rep1 (WrappedMonad m) | |
| type Rep (WrappedMonad m a) | |
newtype WrappedArrow a b c Source
Constructors
| WrapArrow | |
Fields
| |
Instances
| Arrow a => Functor (WrappedArrow a b) | |
| Arrow a => Applicative (WrappedArrow a b) | |
| Generic1 (WrappedArrow a b) | |
| (ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | |
| Generic (WrappedArrow a b c) | |
| type Rep1 (WrappedArrow a b) | |
| type Rep (WrappedArrow a b c) | |
Lists, but with an Applicative functor based on zipping, so that
f<$>ZipListxs1<*>...<*>ZipListxsn =ZipList(zipWithn f xs1 ... xsn)
Constructors
| ZipList | |
Fields
| |
Instances
Utility functions
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 Source
An infix synonym for fmap.
The name of this operator is an allusion to $. Note the similarities between their types:
($) :: (a -> b) -> a -> b (<$>) :: Functor f => (a -> b) -> f a -> f b
Whereas $ is function application, <$> is function application lifted over a Functor.
Examples
Convert from a Maybe Int to a Maybe String using show:
>>>show <$> NothingNothing>>>show <$> Just 3Just "3"
Convert from an Either Int Int to an Either Int String using show:
>>>show <$> Left 17Left 17>>>show <$> Right 17Right "17"
Double each element of a list:
>>>(*2) <$> [1,2,3][2,4,6]
Apply even to the second element of a pair:
>>>even <$> (2,2)(2,True)
(<$) :: Functor f => a -> f b -> f a Source
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 infixl 4 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.
© The University of Glasgow and others
Licensed under a BSD-style license (see top of the page).
https://downloads.haskell.org/~ghc/8.0.1/docs/html/libraries/base-4.9.0.0/Control-Applicative.html
