Portability | portable |
---|---|
Stability | experimental |
Maintainer | libraries@haskell.org |
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.
- class Functor f => Applicative f where
- class Applicative f => Alternative f where
- 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 (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)
Applicative functors
class Functor f => Applicative f whereSource
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 - ignore left value
-
u
*>
v =pure
(const
id
)<*>
u<*>
v - ignore right value
-
u
<*
v =pure
const
<*>
u<*>
v
The Functor
instance should satisfy
fmap
f x =pure
f<*>
x
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.
Applicative [] | |
Applicative IO | |
Applicative Maybe | |
Applicative STM | |
Applicative ZipList | |
Applicative Id | |
Applicative ((->) a) | |
Applicative (Either e) | |
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 whereSource
A monoid on applicative functors.
Minimal complete definition: empty
and <|>
.
some
and many
should be the least solutions of the equations:
The identity of <|>
(<|>) :: f a -> f a -> f aSource
An associative binary operation
One or more.
Zero or more.
Alternative [] | |
Alternative Maybe | |
Alternative STM | |
MonadPlus m => Alternative (WrappedMonad m) | |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) |
Instances
newtype WrappedMonad m a Source
WrapMonad | |
|
Monad m => Functor (WrappedMonad m) | |
Monad m => Applicative (WrappedMonad m) | |
MonadPlus m => Alternative (WrappedMonad m) |
newtype WrappedArrow a b c Source
WrapArrow | |
|
Arrow a => Functor (WrappedArrow a b) | |
Arrow a => Applicative (WrappedArrow a b) | |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) |
Lists, but with an Applicative
functor based on zipping, so that
f<$>
ZipList
xs1<*>
...<*>
ZipList
xsn =ZipList
(zipWithn f xs1 ... xsn)
ZipList | |
|
Utility functions
(<**>) :: 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
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.