This post is written in Literate Haskell. This means that you can copy it into a `.lhs`

file^{1} and run it through a Haskell compiler or interpreter.

Today we’ll talk about…

Comonads ! They are the categoric dual of monads, which means that the type signatures of comonadic functions look like monadic functions, but with the arrow reversed. I am not an expert in category theory, so I won’t go further.

I will use the following typeclass for comonads : it’s from Edward Kmett’s comonad package (split from the infamous category-extras package).

```
class Functor w => Comonad w where
extract :: w a -> a
extend :: (w a -> b) -> w a -> w b
duplicate :: w a -> w (w a)
```

`extend`

or `duplicate`

are optional, as one can be written in terms of the other one. The Monad typeclass, for reference, can be described as^{2} :

```
class Functor m => Monad m where
return :: a -> m a
(=<<) :: (a -> m b) -> m a -> m b
join :: m (m a) -> m a
```

The duality is quite easy to see : `extract`

is the dual of `return`

, `extend`

the one of `(=<<)`

and `duplicate`

the one of `join`

.

So what are comonads good for ?

I stumbled upon an article which explains that they can be used for computations which depend on some local environment, like cellular automata. Comments ask whether it’s possible to generalize to higher dimensions, which I will do by implementing Conway’s Game of Life in a comonadic way.

List zippers are a fantastic data structure, allowing O(1) edits at a “cursor”. Moving the cursor element to element is O(1) too. This makes it a very nice data structure when your edits are local (say, in a text editor). You can learn more about zippers in general in this post from Edward Z Yang. The seminal paper is of course Huet’s article.

A list zipper is composed of a cursor and two lists.

To go in a direction, you pick the head of a list, set it as your cursor, and push the cursor on top of the other list. We assume that we will only infinte lists, so this operation can not fail. This assumption is reasonnable especially in the context of cellular automata^{3}.

```
listLeft :: ListZipper a -> ListZipper a
listLeft (LZ (l:ls) x rs) = LZ ls l (x:rs)
listLeft _ = error "listLeft"
listRight :: ListZipper a -> ListZipper a
listRight (LZ ls x (r:rs)) = LZ (x:ls) r rs
listRight _ = error "listRight"
```

Reading and writing on a list zipper at the cursor is straightforward :

```
listRead :: ListZipper a -> a
listRead (LZ _ x _) = x
listWrite :: a -> ListZipper a -> ListZipper a
listWrite x (LZ ls _ rs) = LZ ls x rs
```

We can also define a function to convert a list zipper to a list, for example for printing. As it’s infinite on both sizes, it’s not possible to convert it to the whole list, so we have to pass a size parameter.

```
toList :: ListZipper a -> Int -> [a]
toList (LZ ls x rs) n =
reverse (take n ls) ++ [x] ++ take n rs
```

We can easily define a `Functor`

instance for `ListZipper`

. To apply a function on whole zipper, we apply it to the cursor and map it on the two lists :

Time for the `Comonad`

instance. The `extract`

method returns an element from the structure : we can pick the one at the cursor.

`duplicate`

is a bit harder to grasp. From a list zipper, we have to build a list zipper of list zippers. The signification behind this (confirmed by the comonad laws that every instance has to fulfill) is that moving inside the duplicated structure returns the original structure, altered by the same move : for example, `listRead (listLeft (duplicate z)) == listLeft z`

.

This means that at the cursor of the duplicated structure, there is the original structure `z`

. And the left list is composed of `listLeft z`

, `listLeft (listLeft z)`

, `listLeft (listLeft (listLeft z))`

, etc (same goes for the right list).

The following function applies repeatedly two movement functions on each side of the zipper (its type is more generic than needed for this specific case but we’ll instanciate `z`

with something other than `ListZipper`

in the next section).

```
genericMove :: (z a -> z a)
-> (z a -> z a)
-> z a
-> ListZipper (z a)
genericMove a b z =
LZ (iterate' a z) z (iterate' b z)
iterate' :: (a -> a) -> a -> [a]
iterate' f = tail . iterate f
```

And finally we can implement the instance.

Using this comonad instance we can already implement 1D cellular automata, as explained in the sigfpe article. Let’s see how they can be extended to 2D automata.

Let’s generalize list zippers to plane zippers, which are cursors on a plane of cells. We will implement them using a list zipper of list zippers.

We start by defining move functions. As a convention, the external list will hold lines : to move up and down, we will really move left and right at the root level.

For left and right, it is necessary to alter every line, using the `Functor`

instance.

```
left :: Z a -> Z a
left (Z z) = Z (fmap listLeft z)
right :: Z a -> Z a
right (Z z) = Z (fmap listRight z)
```

Finally, editing is quite straightforward : reading is direct (first read the line, then the cursor) ; and in order to write, it is necessary to fetch the current line, write to it and write the new line.

```
zRead :: Z a -> a
zRead (Z z) = listRead $ listRead z
zWrite :: a -> Z a -> Z a
zWrite x (Z z) =
Z $ listWrite newLine z
where
newLine = listWrite x oldLine
oldLine = listRead z
```

Time for algebra. Let’s define a `Functor`

instance : applying a function everywhere can be achieved by applying it on every line.

The idea behind the `Comonad`

instance for `Z`

is the same that the `ListZipper`

one : moving “up” in the structure (really, “left” at the root level) returns the original structure moved in this direction.

We will reuse the `genericMove`

defined earlier in order to build list zippers that describe movements in the two axes^{4}.

```
horizontal :: Z a -> ListZipper (Z a)
horizontal = genericMove left right
vertical :: Z a -> ListZipper (Z a)
vertical = genericMove up down
```

This is enough to define the instance.

Let’s define a neighbourhood function. Here, directions are moves on a plane zipper. Neighbours are : horizontal moves, vertical moves and their compositions (`liftM2 (.)`

)^{5}.

```
neighbours :: [Z a -> Z a]
neighbours =
horiz ++ vert ++ liftM2 (.) horiz vert
where
horiz = [left, right]
vert = [up, down]
aliveNeighbours :: Z Bool -> Int
aliveNeighbours z =
card $ map (\ dir -> extract $ dir z) neighbours
card :: [Bool] -> Int
card = length . filter (==True)
```

The core rule of the game fits in the following function : if two neighbours are alive, return the previous state ; if three neighbours are alive, a new cell is born, and any other count causes the cell to die (of under-population or overcrowding).

It is remarkable that its type is the dual of that of a Kleisli arrow (`a -> m b`

).

And then the comonadic magic happens with the use of `extend`

:

`evolve`

is our main transition function between world states, and yet it’s only defined in terms of the local transition function !

Let’s define a small printer to see what’s going on.

```
dispLine :: ListZipper Bool -> String
dispLine z =
map dispC $ toList z 6
where
dispC True = '*'
dispC False = ' '
disp :: Z Bool -> String
disp (Z z) =
unlines $ map dispLine $ toList z 6
```

Here is the classic glider pattern to test. The definition has a lot of boilerplate because we did not bother to create a `fromList`

function.

```
glider :: Z Bool
glider =
Z $ LZ (repeat fz) fz rs
where
rs = [ line [f, t, f]
, line [f, f, t]
, line [t, t, t]
] ++ repeat fz
t = True
f = False
fl = repeat f
fz = LZ fl f fl
line l =
LZ fl f (l ++ fl)
```

```
*Main> putStr $ disp glider
*
*
***
*Main> putStr $ disp $ evolve glider
* *
**
*
```

We did it ! Implementing Conway’s Game of Life is usually full of ad-hoc boilerplate code : iterating loops, managing copies of cells, etc. Using the comonadic structure of cellular automata, the code can be a lot simpler.

In this example, `ListZipper`

and `Z`

should be library functions, so the actual implementation is only a dozen lines long!

The real benefit is that it has really helped be grasp the concept of comonads. I hope that I did not just fall into the comonad tutorial fallacy :)

**Update (March 10th):** Brian Cohen contributed a simple extension to simulate a closed topology. Thanks !

Or download the source on github.↩

In the real Haskell typeclass, there are the following differences: Monad and Functor are not related,

`join`

is a library function (you can’t use it to define an instance),`(>>=)`

is used instead of its flipped counterpart`(=<<)`

and there two more methods`(>>)`

and`fail`

.↩Simulating a closed topology such as a torus may even be possible using cyclic lists instead of lazy infinite lists.

**Update:**see Brian Cohen’s response at the end of this post.↩At first I thought that it was possible to only use the

`Comonad`

instance of`ListZipper`

to define`horizontal`

and`vertical`

, but I couldn’t come up with a solution. But in that case, the`z`

generic parameter is instanciated to`Z`

, not`ListZipper`

. For that reason I believe that my initial thought can’t be implemented. Maybe it’s possible with a comonad transformer or something like that.↩This could have been written in extension as there are only 8 cases, but it’s funnier and arguably less error prone this way :-)↩