Portability  portable 

Stability  provisional 
Maintainer  Edward Kmett <ekmett@gmail.com> 
 class Functor f where
 class Functor w => Comonad w where
 (=>=) :: 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 > (w a > b) > w b
 (<<=) :: Comonad w => (w a > b) > w a > w b
 wfix :: Comonad w => w (w a > a) > a
 unfoldW :: Comonad w => (w b > (a, b)) > w b > [a]
 liftW :: Comonad w => (a > b) > w a > w b
 class Comonad w => ComonadZip w where
 (<..>) :: ComonadZip w => w a > w (a > b) > w b
 liftW2 :: ComonadZip w => (a > b > c) > w a > w b > w c
 liftW3 :: ComonadZip w => (a > b > c > d) > w a > w b > w c > w d
 newtype Cokleisli w a b = Cokleisli {
 runCokleisli :: w a > b
Functor and Comonad
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.
class Functor w => Comonad w whereSource
There are two ways to define a comonad:
I. Provide definitions for extract
and extend
satisfying these laws:
extend extract = id extract . extend f = f extend 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 = f extract =>= 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 id fmap f = extend (f . extract)
These are the default definitions of extend
andduplicate
and
the 'default' definition of liftW
respectively.
Functions
Naming conventions
The functions in this library use the following naming conventions, based on those of Control.Monad.
 A postfix '
W
' always stands for a function in the Cokleisli category: The monad type constructorw
is added to function results (modulo currying) and nowhere else. So, for example,
filter :: (a > Bool) > [a] > [a] filterW :: Comonad w => (w a > Bool) > w [a] > [a]
 A prefix '
w
' generalizes an existing function to a comonadic form. Thus, for example:
fix :: (a > a) > a wfix :: w (w a > a) > a
When ambiguous, consistency with existing Control.Monad combinator naming
supercedes these rules (e.g. liftW
)
Operators
Fixed points and folds
Comonadic lifting
Comonads with Zipping
class Comonad w => ComonadZip w whereSource
As a symmetric semimonoidal comonad, an instance of ComonadZip is required to satisfy:
extract (a <.> b) = extract a (extract b)
Minimal definition: <.>
Based on the ComonadZip from "The Essence of Dataflow Programming" by Tarmo Uustalu and Varmo Vene, but adapted to fit the programming style of Control.Applicative.
ComonadZip Identity  
Monoid m => ComonadZip ((>) m)  
Monoid m => ComonadZip ((,) m)  
ComonadZip w => ComonadZip (IdentityT w) 
(<..>) :: ComonadZip w => w a > w (a > b) > w bSource
A variant of <.>
with the arguments reversed.
liftW2 :: ComonadZip w => (a > b > c) > w a > w b > w cSource
Lift a binary function into a comonad with zipping
liftW3 :: ComonadZip w => (a > b > c > d) > w a > w b > w c > w dSource
Lift a ternary function into a comonad with zipping
Cokleisli Arrows
newtype Cokleisli w a b Source
Cokleisli  
