Portability  portable 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Safe Haskell  None 
 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, Maybe
and IO
satisfy these laws.
($>) :: Functor f => f a > b > f b
Replace the contents of a functor uniformly with a constant value.
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
a .> b = const id <$> a <.> b
(<.) :: 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)  
(Functor (WrappedApplicative f), Applicative f) => Applicative (WrappedApplicative f)  
(Applicative (WrappedApplicative f), Alternative f) => Alternative (WrappedApplicative f)  
(Functor (WrappedApplicative f), Applicative f) => Apply (WrappedApplicative f)  
(Functor (WrappedApplicative f), Alternative f) => Alt (WrappedApplicative 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)  
(Functor (MaybeApply f), Apply f) => Applicative (MaybeApply f)  
(Functor (MaybeApply f), Comonad f) => Comonad (MaybeApply f)  
(Functor (MaybeApply f), Extend f) => Extend (MaybeApply f)  
(Functor (MaybeApply f), Apply f) => Apply (MaybeApply f) 