Portability  portable 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
 class Functor f where
 (<$>) :: Functor f => (a > b) > f a > f b
 ($>) :: Functor f => f a > b > f b
 class Functor f => Apply f where
 (<..>) :: Apply w => w a > w (a > b) > w b
 liftF2 :: Apply w => (a > b > c) > w a > w b > w c
 liftF3 :: Apply w => (a > b > c > d) > w a > w b > w c > w d
 newtype WrappedApplicative f a = WrapApplicative {
 unwrapApplicative :: f a
 newtype MaybeApply f a = MaybeApply {
 runMaybeApply :: Either (f a) a
Functors
class Functor f where
The Functor
class is used for types that can be mapped over.
Instances of Functor
should satisfy the following laws:
fmap id == id fmap (f . g) == fmap f . fmap g
The instances of Functor
for lists, Data.Maybe.Maybe
and System.IO.IO
satisfy these laws.
Apply  a strong lax semimonoidal endofunctor
class Functor f => Apply f whereSource
A strong lax semimonoidal endofunctor.
This is equivalent to an Applicative
without pure
.
Laws:
associative composition: (.) <$> u <.> v <.> w = u <.> (v <.> w)
(<.>) :: f (a > b) > f a > f bSource
(.>) :: f a > f b > f bSource
(<.) :: f a > f b > f aSource
a . b = const <$ a . b
liftF2 :: Apply w => (a > b > c) > w a > w b > w cSource
Lift a binary function into a comonad with zipping
liftF3 :: Apply w => (a > b > c > d) > w a > w b > w c > w dSource
Lift a ternary function into a comonad with zipping
Wrappers
newtype WrappedApplicative f a Source
Wrap an Applicative
to be used as a member of Apply
WrapApplicative  

Functor f => Functor (WrappedApplicative f)  
Applicative f => Applicative (WrappedApplicative f)  
Alternative f => Alternative (WrappedApplicative f)  
Applicative f => Apply (WrappedApplicative f)  
Alternative f => Alt (WrappedApplicative f)  
Alternative f => Plus (WrappedApplicative f) 
newtype MaybeApply f a Source
Transform a Apply into an Applicative by adding a unit.
MaybeApply  

Functor f => Functor (MaybeApply f)  
Apply f => Applicative (MaybeApply f)  
Comonad f => Comonad (MaybeApply f)  
Extend f => Extend (MaybeApply f)  
Apply f => Apply (MaybeApply f) 