Programming in Scala”

Chapter notes 36
counit is pronounced “co-unit”, not “cow-knit”.
We say that F is left adjoint to G, written F ⊣ G in mathematical notation.
There are two laws of adjunctions:
1. counit(F.map(x)(unit)) == x
2. G.map(unit(x))(counit) == x
Another way to view an adjunction is that there is an isomorphism between the types F[A] => B
and A => G[B]:
def leftAdjunct[A,B](k: F[A] => B): A => G[B] =
a => G.map(unit(a))(k)
def rightAdjunct[A,B](k: A => G[B]): F[A] => B =
fa => counit(F.map(fa)(k))
An adjunction has the property that G[F[_]] is a monad:
def join[A](g: G[F[G[F[A]]]]): G[F[A]] =
G.map(g)(counit)
def map[A,B](g: G[F[A]])(f: A => B): G[F[B]] =
G.map(F.map(f))
def flatMap[A,B](g: G[F[A]])(f: A => G[F[B]]): G[F[B]] =
join(map(g)(f))
For example, the State monad is formed by the adjoint functors (_, S) and S => _.
In fact, every monad is formed by an adjunction.
Comonads
Dually¹⁵⁴, the composite functor F[G[A]] is a comonad¹⁵⁵. A comonad is exactly like a monad, except
the direction of the function arrows is reversed:
trait Comonad[F[_]] {
}
def counit[A](a: F[A]): A
def extend[A,B](a: F[A])(f: F[A] => B): F[B]
Instead of a unit that goes from A to F[A], we have a counit that goes from F[A] to A. And instead
of a flatMap that takes a function of type A => F[B], we have extend that takes a function going
the other way: F[A] => B.
A simple example of a comonad is the reader comonad:
¹⁵⁴http://en.wikipedia.org/wiki/Dual_%28mathematics%29
¹⁵⁵http://docs.typelevel.org/api/scalaz/stable/7.1.0-M3/doc/#scalaz.Comonad