Safe Haskell	Safe

Eta.Classes.Applicative

Synopsis

Documentation

class Functor f => Applicative f where #

Minimal complete definition

pure, (<*>)

Methods

pure :: a -> f a #

(<*>) :: f (a -> b) -> f a -> f b #

Instances

Applicative []
Methods pure :: a -> [a] # (<>) :: [a -> b] -> [a] -> [b] # (>) :: [a] -> [b] -> [b] (<*) :: [a] -> [b] -> [a]
Applicative Maybe
Methods pure :: a -> Maybe a # (<>) :: Maybe (a -> b) -> Maybe a -> Maybe b # (>) :: Maybe a -> Maybe b -> Maybe b (<*) :: Maybe a -> Maybe b -> Maybe a
Applicative IO
Methods pure :: a -> IO a # (<>) :: IO (a -> b) -> IO a -> IO b # (>) :: IO a -> IO b -> IO b (<*) :: IO a -> IO b -> IO a
Applicative U1
Methods pure :: a -> U1 a # (<>) :: U1 (a -> b) -> U1 a -> U1 b # (>) :: U1 a -> U1 b -> U1 b (<*) :: U1 a -> U1 b -> U1 a
Applicative Par1
Methods pure :: a -> Par1 a # (<>) :: Par1 (a -> b) -> Par1 a -> Par1 b # (>) :: Par1 a -> Par1 b -> Par1 b (<*) :: Par1 a -> Par1 b -> Par1 a
Applicative Sum
Methods pure :: a -> Sum a # (<>) :: Sum (a -> b) -> Sum a -> Sum b # (>) :: Sum a -> Sum b -> Sum b (<*) :: Sum a -> Sum b -> Sum a
Applicative Product
Methods pure :: a -> Product a # (<>) :: Product (a -> b) -> Product a -> Product b # (>) :: Product a -> Product b -> Product b (<*) :: Product a -> Product b -> Product a
Applicative Last
Methods pure :: a -> Last a # (<>) :: Last (a -> b) -> Last a -> Last b # (>) :: Last a -> Last b -> Last b (<*) :: Last a -> Last b -> Last a
Applicative First
Methods pure :: a -> First a # (<>) :: First (a -> b) -> First a -> First b # (>) :: First a -> First b -> First b (<*) :: First a -> First b -> First a
Applicative Dual
Methods pure :: a -> Dual a # (<>) :: Dual (a -> b) -> Dual a -> Dual b # (>) :: Dual a -> Dual b -> Dual b (<*) :: Dual a -> Dual b -> Dual a
Applicative ZipList
Methods pure :: a -> ZipList a # (<>) :: ZipList (a -> b) -> ZipList a -> ZipList b # (>) :: ZipList a -> ZipList b -> ZipList b (<*) :: ZipList a -> ZipList b -> ZipList a
Applicative Id
Methods pure :: a -> Id a # (<>) :: Id (a -> b) -> Id a -> Id b # (>) :: Id a -> Id b -> Id b (<*) :: Id a -> Id b -> Id a
Applicative ((->) a)
Methods pure :: a -> a -> a # (<>) :: (a -> a -> b) -> (a -> a) -> a -> b # (>) :: (a -> a) -> (a -> b) -> a -> b (<*) :: (a -> a) -> (a -> b) -> a -> a
Applicative (Either e)
Methods pure :: a -> Either e a # (<>) :: Either e (a -> b) -> Either e a -> Either e b # (>) :: Either e a -> Either e b -> Either e b (<*) :: Either e a -> Either e b -> Either e a
Applicative f => Applicative (Rec1 f)
Methods pure :: a -> Rec1 f a # (<>) :: Rec1 f (a -> b) -> Rec1 f a -> Rec1 f b # (>) :: Rec1 f a -> Rec1 f b -> Rec1 f b (<*) :: Rec1 f a -> Rec1 f b -> Rec1 f a
Monoid a => Applicative ((,) a)
Methods pure :: a -> (a, a) # (<>) :: (a, a -> b) -> (a, a) -> (a, b) # (>) :: (a, a) -> (a, b) -> (a, b) (<*) :: (a, a) -> (a, b) -> (a, a)
Monad m => Applicative (WrappedMonad m)
Methods pure :: a -> WrappedMonad m a # (<>) :: WrappedMonad m (a -> b) -> WrappedMonad m a -> WrappedMonad m b # (>) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m b (<*) :: WrappedMonad m a -> WrappedMonad m b -> WrappedMonad m a
Applicative (Proxy *)
Methods pure :: a -> Proxy * a # (<>) :: Proxy (a -> b) -> Proxy * a -> Proxy * b # (>) :: Proxy a -> Proxy * b -> Proxy * b (<) :: Proxy a -> Proxy * b -> Proxy * a
Applicative (StateR s)
Methods pure :: a -> StateR s a # (<>) :: StateR s (a -> b) -> StateR s a -> StateR s b # (>) :: StateR s a -> StateR s b -> StateR s b (<*) :: StateR s a -> StateR s b -> StateR s a
Applicative (StateL s)
Methods pure :: a -> StateL s a # (<>) :: StateL s (a -> b) -> StateL s a -> StateL s b # (>) :: StateL s a -> StateL s b -> StateL s b (<*) :: StateL s a -> StateL s b -> StateL s a
(Applicative f, Applicative g) => Applicative ((:*:) f g)
Methods pure :: a -> (f :: g) a # (<>) :: (f :: g) (a -> b) -> (f :: g) a -> (f :: g) b # (>) :: (f :: g) a -> (f :: g) b -> (f :: g) b (<) :: (f :: g) a -> (f :: g) b -> (f :*: g) a
(Applicative f, Applicative g) => Applicative ((:.:) f g)
Methods pure :: a -> (f :.: g) a # (<>) :: (f :.: g) (a -> b) -> (f :.: g) a -> (f :.: g) b # (>) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) b (<*) :: (f :.: g) a -> (f :.: g) b -> (f :.: g) a
Applicative f => Applicative (Alt * f)
Methods pure :: a -> Alt * f a # (<>) :: Alt f (a -> b) -> Alt * f a -> Alt * f b # (>) :: Alt f a -> Alt * f b -> Alt * f b (<) :: Alt f a -> Alt * f b -> Alt * f a
Arrow a => Applicative (WrappedArrow a b)
Methods pure :: a -> WrappedArrow a b a # (<>) :: WrappedArrow a b (a -> b) -> WrappedArrow a b a -> WrappedArrow a b b # (>) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b b (<*) :: WrappedArrow a b a -> WrappedArrow a b b -> WrappedArrow a b a
Applicative f => Applicative (M1 i c f)
Methods pure :: a -> M1 i c f a # (<>) :: M1 i c f (a -> b) -> M1 i c f a -> M1 i c f b # (>) :: M1 i c f a -> M1 i c f b -> M1 i c f b (<*) :: M1 i c f a -> M1 i c f b -> M1 i c f a

apply :: Applicative f => f (a -> b) -> f a -> f b #

The Applicative type class defines that a type can have an apply operation which can be used to apply a function contained in the Applicative to the elements of Another.

All types that implement Applicative must implement Functor.

The Maybe type is an example of an instance of Applicative.

>>> apply (Just (+1)) (Just 2)
Just 3

Mnemonic: Applyable

(<*|) :: Applicative f => f (a -> b) -> f a -> f b #

Applies the function contained in the Applicative of the left to the Applicative which contains a value of the right:

>>> Just (+ 1) <*| Just 2
Just 3

(|*>) :: Applicative f => f a -> f (a -> b) -> f b #

Applies the function contained in the Applicative of the right to the Applicative which contains a value of the left:

>>> Just 1 |*> Just (+2)
Just 3