Safe Haskell | Safe |
---|---|
Language | Haskell2010 |
- class Functor f => Applicative (f :: * -> *) where
- class Applicative f => Alternative (f :: * -> *) where
- data Const k a (b :: k) :: forall k. * -> k -> *
- data WrappedMonad (m :: * -> *) a :: (* -> *) -> * -> *
- data WrappedArrow (a :: * -> * -> *) b c :: (* -> * -> *) -> * -> * -> *
- data ZipList a :: * -> *
- (<$>) :: Functor f => (a -> b) -> f a -> f b
- (<$) :: Functor f => forall a b. 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 => forall a b c. (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)
Documentation
class Functor f => Applicative (f :: * -> *) where #
A functor with application, providing operations to
A minimal complete definition must include implementations of pure
and of either <*>
or liftA2
. If it defines both, then they must behave
the same as their default definitions:
(
<*>
) = liftA2
id
liftA2
f x y = f <$>
x <*>
y
Further, any definition must satisfy the following:
- 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 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
It may be useful to note that supposing
forall x y. p (q x y) = f x . g y
it follows from the above that
liftA2
p (liftA2
q u v) =liftA2
f u .liftA2
g v
If f
is also a Monad
, it should satisfy
(which implies that pure
and <*>
satisfy the applicative functor laws).
Lift a value.
(<*>) :: f (a -> b) -> f a -> f b infixl 4 #
Sequential application.
A few functors support an implementation of <*>
that is more
efficient than the default one.
liftA2 :: (a -> b -> c) -> f a -> f b -> f c #
Lift a binary function to actions.
Some functors support an implementation of liftA2
that is more
efficient than the default one. In particular, if fmap
is an
expensive operation, it is likely better to use liftA2
than to
fmap
over the structure and then use <*>
.
(*>) :: f a -> f b -> f b infixl 4 #
Sequence actions, discarding the value of the first argument.
(<*) :: f a -> f b -> f a infixl 4 #
Sequence actions, discarding the value of the second argument.
Applicative [] | Since: 2.1 |
Applicative Maybe | Since: 2.1 |
Applicative IO | Since: 2.1 |
Applicative Min | Since: 4.9.0.0 |
Applicative Max | Since: 4.9.0.0 |
Applicative First | Since: 4.9.0.0 |
Applicative Last | Since: 4.9.0.0 |
Applicative Option | Since: 4.9.0.0 |
Applicative NonEmpty | Since: 4.9.0.0 |
Applicative ZipList | f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN
|
Applicative Dual | Since: 4.8.0.0 |
Applicative Sum | Since: 4.8.0.0 |
Applicative Product | Since: 4.8.0.0 |
Applicative First | |
Applicative Last | |
Applicative (Either e) | Since: 3.0 |
Monoid a => Applicative ((,) a) | For tuples, the ("hello ", (+15)) <*> ("world!", 2002) ("hello world!",2017) Since: 2.1 |
Monad m => Applicative (WrappedMonad m) | Since: 2.1 |
Arrow a => Applicative (WrappedArrow a b) | Since: 2.1 |
Monoid m => Applicative (Const * m) | Since: 2.0.1 |
Applicative f => Applicative (Alt * f) | |
Applicative ((->) LiftedRep LiftedRep a) | Since: 2.1 |
class Applicative f => Alternative (f :: * -> *) where #
A monoid on applicative functors.
If defined, some
and many
should be the least solutions
of the equations:
The identity of <|>
(<|>) :: f a -> f a -> f a infixl 3 #
An associative binary operation
One or more.
Zero or more.
Alternative [] | Since: 2.1 |
Alternative Maybe | Since: 2.1 |
Alternative IO | Since: 4.9.0.0 |
Alternative Option | Since: 4.9.0.0 |
MonadPlus m => Alternative (WrappedMonad m) | Since: 2.1 |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: 2.1 |
Alternative f => Alternative (Alt * f) | |
data Const k a (b :: k) :: forall k. * -> k -> * #
The Const
functor.
Generic1 k (Const k a) | |
Functor (Const * m) | Since: 2.1 |
Monoid m => Applicative (Const * m) | Since: 2.0.1 |
Foldable (Const * m) | Since: 4.7.0.0 |
Traversable (Const * m) | Since: 4.7.0.0 |
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
Since: 4.8.0.0 |
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
Since: 4.8.0.0 |
Ix a => Ix (Const k a b) | |
IsString a => IsString (Const * a b) | Since: 4.9.0.0 |
Generic (Const k a b) | |
Semigroup a => Semigroup (Const k a b) | Since: 4.9.0.0 |
Monoid a => Monoid (Const k a b) | |
Storable a => Storable (Const k a b) | |
Bits a => Bits (Const k a b) | |
FiniteBits a => FiniteBits (Const k a b) | |
type Rep1 k (Const k a) | |
type Rep (Const k a b) | |
data WrappedMonad (m :: * -> *) a :: (* -> *) -> * -> * #
Monad m => Monad (WrappedMonad m) | |
Monad m => Functor (WrappedMonad m) | Since: 2.1 |
Monad m => Applicative (WrappedMonad m) | Since: 2.1 |
MonadPlus m => Alternative (WrappedMonad m) | Since: 2.1 |
Generic1 * (WrappedMonad m) | |
Generic (WrappedMonad m a) | |
type Rep1 * (WrappedMonad m) | |
type Rep (WrappedMonad m a) | |
data WrappedArrow (a :: * -> * -> *) b c :: (* -> * -> *) -> * -> * -> * #
Generic1 * (WrappedArrow a b) | |
Arrow a => Functor (WrappedArrow a b) | Since: 2.1 |
Arrow a => Applicative (WrappedArrow a b) | Since: 2.1 |
(ArrowZero a, ArrowPlus a) => Alternative (WrappedArrow a b) | Since: 2.1 |
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.
Functor ZipList | |
Applicative ZipList | f '<$>' 'ZipList' xs1 '<*>' ... '<*>' 'ZipList' xsN
|
Foldable ZipList | |
Traversable ZipList | Since: 4.9.0.0 |
Eq a => Eq (ZipList a) | |
Ord a => Ord (ZipList a) | |
Read a => Read (ZipList a) | |
Show a => Show (ZipList a) | |
Generic (ZipList a) | |
Generic1 * ZipList | |
type Rep (ZipList a) | |
type Rep1 * ZipList | |
(<$>) :: Functor f => (a -> b) -> f a -> f b infixl 4 #
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
to a Maybe
Int
using Maybe
String
show
:
>>>
show <$> Nothing
Nothing>>>
show <$> Just 3
Just "3"
Convert from an
to an Either
Int
Int
Either
Int
String
using show
:
>>>
show <$> Left 17
Left 17>>>
show <$> Right 17
Right "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)
(<**>) :: Applicative f => f a -> f (a -> b) -> f b infixl 4 #
A variant of <*>
with the arguments reversed.
liftA :: Applicative f => (a -> b) -> f a -> f b #
liftA2 :: Applicative f => forall a b c. (a -> b -> c) -> f a -> f b -> f c #
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.