Copyright  (C) 20112015 Edward Kmett 

License  BSDstyle (see the file LICENSE) 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  provisional 
Portability  portable 
Safe Haskell  Trustworthy 
Language  Haskell2010 
Synopsis
 class Functor (f :: Type > Type) 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
 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
 class Apply m => Bind m where
 (<<) :: Bind m => (a > m b) > m a > m b
 (<) :: Bind m => (b > m c) > (a > m b) > a > m c
 (>) :: Bind m => (a > m b) > (b > m c) > a > m c
 apDefault :: Bind f => f (a > b) > f a > f b
 returning :: Functor f => f a > (a > b) > f b
Functors
class Functor (f :: Type > Type) where Source #
A type f
is a Functor if it provides a function fmap
which, given any types a
and b
lets you apply any function from (a > b)
to turn an f a
into an f b
, preserving the
structure of f
. Furthermore f
needs to adhere to the following:
Note, that the second law follows from the free theorem of the type fmap
and
the first law, so you need only check that the former condition holds.
fmap :: (a > b) > f a > f b Source #
Using ApplicativeDo
: '
' can be understood as
the fmap
f asdo
expression
do a < as pure (f a)
with an inferred Functor
constraint.
Instances
Functor []  Since: base2.1 
Functor Maybe  Since: base2.1 
Functor IO  Since: base2.1 
Functor Par1  Since: base4.9.0.0 
Functor Q  
Functor Complex  Since: base4.9.0.0 
Functor Min  Since: base4.9.0.0 
Functor Max  Since: base4.9.0.0 
Functor First  Since: base4.9.0.0 
Functor Last  Since: base4.9.0.0 
Functor Option  Since: base4.9.0.0 
Functor ZipList  Since: base2.1 
Functor Identity  Since: base4.8.0.0 
Functor Handler  Since: base4.6.0.0 
Functor STM  Since: base4.3.0.0 
Functor First  Since: base4.8.0.0 
Functor Last  Since: base4.8.0.0 
Functor Dual  Since: base4.8.0.0 
Functor Sum  Since: base4.8.0.0 
Functor Product  Since: base4.8.0.0 
Functor Down  Since: base4.11.0.0 
Functor ReadP  Since: base2.1 
Functor NonEmpty  Since: base4.9.0.0 
Functor IntMap  
Functor Tree  
Functor Seq  
Functor FingerTree  
Defined in Data.Sequence.Internal fmap :: (a > b) > FingerTree a > FingerTree b Source # (<$) :: a > FingerTree b > FingerTree a Source #  
Functor Digit  
Functor Node  
Functor Elem  
Functor ViewL  
Functor ViewR  
Functor Doc  
Functor AnnotDetails  
Defined in Text.PrettyPrint.Annotated.HughesPJ fmap :: (a > b) > AnnotDetails a > AnnotDetails b Source # (<$) :: a > AnnotDetails b > AnnotDetails a Source #  
Functor Span  
Functor P  Since: base4.8.0.0 
Functor (Either a)  Since: base3.0 
Functor (V1 :: Type > Type)  Since: base4.9.0.0 
Functor (U1 :: Type > Type)  Since: base4.9.0.0 
Functor ((,) a)  Since: base2.1 
Functor (Array i)  Since: base2.1 
Functor (Arg a)  Since: base4.9.0.0 
Monad m => Functor (WrappedMonad m)  Since: base2.1 
Defined in Control.Applicative fmap :: (a > b) > WrappedMonad m a > WrappedMonad m b Source # (<$) :: a > WrappedMonad m b > WrappedMonad m a Source #  
Arrow a => Functor (ArrowMonad a)  Since: base4.6.0.0 
Defined in Control.Arrow fmap :: (a0 > b) > ArrowMonad a a0 > ArrowMonad a b Source # (<$) :: a0 > ArrowMonad a b > ArrowMonad a a0 Source #  
Functor (Proxy :: Type > Type)  Since: base4.7.0.0 
Functor (Map k)  
Functor f => Functor (Lift f)  
Functor m => Functor (MaybeT m)  
Functor m => Functor (ListT m)  
Functor (HashMap k)  
Functor f => Functor (MaybeApply f) Source #  
Defined in Data.Functor.Bind.Class fmap :: (a > b) > MaybeApply f a > MaybeApply f b Source # (<$) :: a > MaybeApply f b > MaybeApply f a Source #  
Functor f => Functor (WrappedApplicative f) Source #  
Defined in Data.Functor.Bind.Class fmap :: (a > b) > WrappedApplicative f a > WrappedApplicative f b Source # (<$) :: a > WrappedApplicative f b > WrappedApplicative f a Source #  
Functor f => Functor (Rec1 f)  Since: base4.9.0.0 
Functor (URec Char :: Type > Type)  Since: base4.9.0.0 
Functor (URec Double :: Type > Type)  Since: base4.9.0.0 
Functor (URec Float :: Type > Type)  Since: base4.9.0.0 
Functor (URec Int :: Type > Type)  Since: base4.9.0.0 
Functor (URec Word :: Type > Type)  Since: base4.9.0.0 
Functor (URec (Ptr ()) :: Type > Type)  Since: base4.9.0.0 
Functor ((,,) a b)  Since: base4.14.0.0 
Arrow a => Functor (WrappedArrow a b)  Since: base2.1 
Defined in Control.Applicative fmap :: (a0 > b0) > WrappedArrow a b a0 > WrappedArrow a b b0 Source # (<$) :: a0 > WrappedArrow a b b0 > WrappedArrow a b a0 Source #  
Functor m => Functor (Kleisli m a)  Since: base4.14.0.0 
Functor (Const m :: Type > Type)  Since: base2.1 
Functor f => Functor (Ap f)  Since: base4.12.0.0 
Functor f => Functor (Alt f)  Since: base4.8.0.0 
Bifunctor p => Functor (Join p)  
Functor w => Functor (TracedT m w)  
Functor w => Functor (StoreT s w)  
Functor w => Functor (EnvT e w)  
Functor m => Functor (IdentityT m)  
(Applicative f, Monad f) => Functor (WhenMissing f x)  Since: containers0.5.9 
Defined in Data.IntMap.Internal fmap :: (a > b) > WhenMissing f x a > WhenMissing f x b Source # (<$) :: a > WhenMissing f x b > WhenMissing f x a Source #  
Functor (Tagged s)  
Functor f => Functor (Reverse f)  Derived instance. 
Functor (Constant a :: Type > Type)  
Functor m => Functor (WriterT w m)  
Functor m => Functor (WriterT w m)  
Functor m => Functor (WriterT w m)  
Functor m => Functor (StateT s m)  
Functor m => Functor (StateT s m)  
Functor m => Functor (ReaderT r m)  
Functor m => Functor (ExceptT e m)  
Functor m => Functor (ErrorT e m)  
Functor f => Functor (Backwards f)  Derived instance. 
Functor (Mag a b)  
Functor f => Functor (Static f a) Source #  
Functor ((>) r :: Type > Type)  Since: base2.1 
Functor (K1 i c :: Type > Type)  Since: base4.9.0.0 
(Functor f, Functor g) => Functor (f :+: g)  Since: base4.9.0.0 
(Functor f, Functor g) => Functor (f :*: g)  Since: base4.9.0.0 
Functor ((,,,) a b c)  Since: base4.14.0.0 
(Functor f, Functor g) => Functor (Product f g)  Since: base4.9.0.0 
(Functor f, Functor g) => Functor (Sum f g)  Since: base4.9.0.0 
Functor (Cokleisli w a)  
Functor f => Functor (WhenMatched f x y)  Since: containers0.5.9 
Defined in Data.IntMap.Internal fmap :: (a > b) > WhenMatched f x y a > WhenMatched f x y b Source # (<$) :: a > WhenMatched f x y b > WhenMatched f x y a Source #  
(Applicative f, Monad f) => Functor (WhenMissing f k x)  Since: containers0.5.9 
Defined in Data.Map.Internal fmap :: (a > b) > WhenMissing f k x a > WhenMissing f k x b Source # (<$) :: a > WhenMissing f k x b > WhenMissing f k x a Source #  
Functor (ContT r m)  
Functor f => Functor (M1 i c f)  Since: base4.9.0.0 
(Functor f, Functor g) => Functor (f :.: g)  Since: base4.9.0.0 
(Functor f, Functor g) => Functor (Compose f g)  Since: base4.9.0.0 
Bifunctor p => Functor (WrappedBifunctor p a)  
Defined in Data.Bifunctor.Wrapped fmap :: (a0 > b) > WrappedBifunctor p a a0 > WrappedBifunctor p a b Source # (<$) :: a0 > WrappedBifunctor p a b > WrappedBifunctor p a a0 Source #  
Functor g => Functor (Joker g a)  
Bifunctor p => Functor (Flip p a)  
Functor (Clown f a :: Type > Type)  
Functor f => Functor (WhenMatched f k x y)  Since: containers0.5.9 
Defined in Data.Map.Internal fmap :: (a > b) > WhenMatched f k x y a > WhenMatched f k x y b Source # (<$) :: a > WhenMatched f k x y b > WhenMatched f k x y a Source #  
Functor m => Functor (RWST r w s m)  
Functor m => Functor (RWST r w s m)  
Functor m => Functor (RWST r w s m)  
(Functor f, Bifunctor p) => Functor (Tannen f p a)  
(Bifunctor p, Functor g) => Functor (Biff p f g a)  
(<$>) :: Functor f => (a > b) > f a > f b infixl 4 Source #
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)
($>) :: Functor f => f a > b > f b infixl 4 Source #
Flipped version of <$
.
Using ApplicativeDo
: 'as
' can be understood as the
$>
bdo
expression
do as pure b
with an inferred Functor
constraint.
Examples
Replace the contents of a
with a constant
Maybe
Int
String
:
>>>
Nothing $> "foo"
Nothing>>>
Just 90210 $> "foo"
Just "foo"
Replace the contents of an
with a constant Either
Int
Int
String
, resulting in an
:Either
Int
String
>>>
Left 8675309 $> "foo"
Left 8675309>>>
Right 8675309 $> "foo"
Right "foo"
Replace each element of a list with a constant String
:
>>>
[1,2,3] $> "foo"
["foo","foo","foo"]
Replace the second element of a pair with a constant String
:
>>>
(1,2) $> "foo"
(1,"foo")
Since: base4.7.0.0
Applyable functors
class Functor f => Apply f where Source #
A strong lax semimonoidal endofunctor.
This is equivalent to an Applicative
without pure
.
Laws:
(.
)<$>
u<.>
v<.>
w = u<.>
(v<.>
w) x<.>
(f<$>
y) = (.
f)<$>
x<.>
y f<$>
(x<.>
y) = (f.
)<$>
x<.>
y
The laws imply that .>
and <.
really ignore their
left and right results, respectively, and really
return their right and left results, respectively.
Specifically,
(mf<$>
m).>
(nf<$>
n) = nf<$>
(m.>
n) (mf<$>
m)<.
(nf<$>
n) = mf<$>
(m<.
n)
(<.>) :: f (a > b) > f a > f b infixl 4 Source #
(.>) :: f a > f b > f b infixl 4 Source #
(<.) :: f a > f b > f a infixl 4 Source #
liftF2 :: (a > b > c) > f a > f b > f c Source #
Lift a binary function into a comonad with zipping
Instances
(<..>) :: Apply w => w a > w (a > b) > w b infixl 4 Source #
A variant of <.>
with the arguments reversed.
liftF3 :: Apply w => (a > b > c > d) > w a > w b > w c > w d Source #
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  

Instances
newtype MaybeApply f a Source #
Transform an Apply into an Applicative by adding a unit.
MaybeApply  

Instances
Bindable functors
class Apply m => Bind m where Source #
Minimal definition: Either join
or >>
If defining both, then the following laws (the default definitions) must hold:
join = (>> id) m >> f = join (fmap f m)
Laws:
induced definition of <.>: f <.> x = f >> (<$> x)
Finally, there are two associativity conditions:
associativity of (>>): (m >> f) >> g == m >> (\x > f x >> g) associativity of join: join . join = join . fmap join
These can both be seen as special cases of the constraint that
associativity of (>): (f > g) > h = f > (g > h)