File: README.markdown

package info (click to toggle)
haskell-comonad 5.0.5-1
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, sid
  • size: 192 kB
  • sloc: haskell: 861; makefile: 4
file content (60 lines) | stat: -rwxr-xr-x 2,011 bytes parent folder | download | duplicates (2)
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
=======

[![Hackage](https://img.shields.io/hackage/v/comonad.svg)](https://hackage.haskell.org/package/comonad) [![Build Status](https://secure.travis-ci.org/ekmett/comonad.svg?branch=master)](http://travis-ci.org/ekmett/comonad)

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