Copyright  (C) 20082015 Edward Kmett, (C) 2004 Dave Menendez 

License  BSDstyle (see the file LICENSE) 
Maintainer  Edward Kmett <ekmett@gmail.com> 
Stability  provisional 
Portability  portable 
Safe Haskell  Safe 
Language  Haskell2010 
 class Functor w => Comonad w where
 liftW :: Comonad w => (a > b) > w a > w b
 wfix :: Comonad w => w (w a > a) > a
 cfix :: Comonad w => (w a > a) > w a
 kfix :: ComonadApply w => w (w a > a) > w a
 (=>=) :: Comonad w => (w a > b) > (w b > c) > w a > c
 (=<=) :: Comonad w => (w b > c) > (w a > b) > w a > c
 (<<=) :: Comonad w => (w a > b) > w a > w b
 (=>>) :: Comonad w => w a > (w a > b) > w b
 class Comonad w => ComonadApply w where
 (<@@>) :: ComonadApply w => w a > w (a > b) > w b
 liftW2 :: ComonadApply w => (a > b > c) > w a > w b > w c
 liftW3 :: ComonadApply w => (a > b > c > d) > w a > w b > w c > w d
 newtype Cokleisli w a b = Cokleisli {
 runCokleisli :: w a > b
 class Functor f where
 (<$>) :: Functor f => (a > b) > f a > f b
 ($>) :: Functor f => f a > b > f b
Comonads
class Functor w => Comonad w where Source
There are two ways to define a comonad:
I. Provide definitions for extract
and extend
satisfying these laws:
extend
extract
=id
extract
.extend
f = fextend
f .extend
g =extend
(f .extend
g)
In this case, you may simply set fmap
= liftW
.
These laws are directly analogous to the laws for monads and perhaps can be made clearer by viewing them as laws stating that Cokleisli composition must be associative, and has extract for a unit:
f=>=
extract
= fextract
=>=
f = f (f=>=
g)=>=
h = f=>=
(g=>=
h)
II. Alternately, you may choose to provide definitions for fmap
,
extract
, and duplicate
satisfying these laws:
extract
.duplicate
=id
fmap
extract
.duplicate
=id
duplicate
.duplicate
=fmap
duplicate
.duplicate
In this case you may not rely on the ability to define fmap
in
terms of liftW
.
You may of course, choose to define both duplicate
and extend
.
In that case you must also satisfy these laws:
extend
f =fmap
f .duplicate
duplicate
=extend
idfmap
f =extend
(f .extract
)
These are the default definitions of extend
and duplicate
and
the definition of liftW
respectively.
Comonad Tree  
Comonad NonEmpty  
Comonad Identity  
Monoid m => Comonad ((>) m)  
Comonad ((,) e)  
Comonad (Arg e)  
Comonad w => Comonad (IdentityT w)  
Comonad (Tagged * s)  
Comonad w => Comonad (EnvT e w)  
Comonad w => Comonad (StoreT s w)  
(Comonad w, Monoid m) => Comonad (TracedT m w)  
(Comonad f, Comonad g) => Comonad (Coproduct f g) 
kfix :: ComonadApply w => w (w a > a) > w a Source
Comonadic fixed point à la Kenneth Foner:
This is the evaluate
function from his "Getting a Quick Fix on Comonads" talk.
(=>=) :: Comonad w => (w a > b) > (w b > c) > w a > c infixr 1 Source
Lefttoright Cokleisli
composition
(=<=) :: Comonad w => (w b > c) > (w a > b) > w a > c infixr 1 Source
Righttoleft Cokleisli
composition
Combining Comonads
class Comonad w => ComonadApply w where Source
ComonadApply
is to Comonad
like Applicative
is to Monad
.
Mathematically, it is a strong lax symmetric semimonoidal comonad on the
category Hask
of Haskell types. That it to say that w
is a strong lax
symmetric semimonoidal functor on Hask, where both extract
and duplicate
are
symmetric monoidal natural transformations.
Laws:
(.
)<$>
u<@>
v<@>
w = u<@>
(v<@>
w)extract
(p<@>
q) =extract
p (extract
q)duplicate
(p<@>
q) = (<@>
)<$>
duplicate
p<@>
duplicate
q
If our type is both a ComonadApply
and Applicative
we further require
(<*>
) = (<@>
)
Finally, if you choose to define (<@
) and (@>
), the results of your
definitions should match the following laws:
a@>
b =const
id
<$>
a<@>
b a<@
b =const
<$>
a<@>
b
ComonadApply Tree  
ComonadApply NonEmpty  
ComonadApply Identity  
Monoid m => ComonadApply ((>) m)  
Semigroup m => ComonadApply ((,) m)  
ComonadApply w => ComonadApply (IdentityT w)  
(Semigroup e, ComonadApply w) => ComonadApply (EnvT e w)  
(ComonadApply w, Semigroup s) => ComonadApply (StoreT s w)  
(ComonadApply w, Monoid m) => ComonadApply (TracedT m w) 
(<@@>) :: ComonadApply w => w a > w (a > b) > w b infixl 4 Source
A variant of <@>
with the arguments reversed.
liftW2 :: ComonadApply w => (a > b > c) > w a > w b > w c Source
Lift a binary function into a Comonad
with zipping
liftW3 :: ComonadApply w => (a > b > c > d) > w a > w b > w c > w d Source
Lift a ternary function into a Comonad
with zipping
Cokleisli Arrows
newtype Cokleisli w a b Source
Cokleisli  

Comonad w => Category * (Cokleisli w)  
Comonad w => Arrow (Cokleisli w)  
Comonad w => ArrowChoice (Cokleisli w)  
Comonad w => ArrowApply (Cokleisli w)  
ComonadApply w => ArrowLoop (Cokleisli w)  
Monad (Cokleisli w a)  
Functor (Cokleisli w a)  
Applicative (Cokleisli w a)  
Typeable ((* > *) > * > * > *) Cokleisli 
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 []  
Functor IO  
Functor Id  
Functor ZipList  
Functor ReadPrec  
Functor ReadP  
Functor Maybe  
Functor Tree  
Functor Min  
Functor Max  
Functor First  
Functor Last  
Functor Option  
Functor NonEmpty  
Functor Identity  
Functor ((>) r)  
Functor (Either a)  
Functor ((,) a)  
Ix i => Functor (Array i)  
Functor (StateL s)  
Functor (StateR s)  
Functor (Const m)  
Monad m => Functor (WrappedMonad m)  
Arrow a => Functor (ArrowMonad a)  
Functor (Arg a)  
Functor m => Functor (IdentityT m)  
Functor (HashMap k)  
Arrow a => Functor (WrappedArrow a b)  
Functor (Tagged k s)  
(Functor f, Functor g) => Functor (Compose f g)  
Functor (Cokleisli w a)  
Functor w => Functor (EnvT e w)  
Functor w => Functor (StoreT s w)  
Functor w => Functor (TracedT m w)  
(Functor f, Functor g) => Functor (Coproduct f g) 