| Portability | portable |
|---|---|
| Stability | provisional |
| Maintainer | Edward Kmett <ekmett@gmail.com> |
Control.Comonad
Contents
- 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 constructorwis 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 semi-monoidal 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.
Instances
| 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
Constructors
| Cokleisli | |
Fields
| |