1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
|
comonad
=======
[](https://github.com/ekmett/comonad/actions?query=workflow%3AHaskell-CI)
This package provides comonads, the categorical dual of monads. The typeclass
provides three methods: `extract`, `duplicate`, and `extend`.
class Functor w => Comonad w where
extract :: w a -> a
duplicate :: w a -> w (w a)
extend :: (w a -> b) -> w a -> w b
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](https://wiki.haskell.org/Monad_laws). The comonad laws can
perhaps be made clearer by viewing them as stating that Cokleisli composition
must be a) associative and b) have `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 implementations are the default definitions of `extend` and`duplicate` and
the definition of `liftW` respectively.
Contact Information
-------------------
Contributions and bug reports are welcome!
Please feel free to contact me through github or on the #haskell IRC channel on irc.freenode.net.
-Edward Kmett
|
