Forall.scala

object Forall {
  trait Forall[F[_]] { def apply[A]: F[A] }
  trait Forall2[F[_, _]] { def apply[A, B]: F[A, B] }
  
  type ~>[F[_], G[_]]        = Forall[ λ[ A =>     F[A]    => G[A]]]
  type ~~>[F[_, _], G[_, _]] = Forall2[λ[(A, B) => F[A, B] => G[A, B]]]
  
  type Id[A] = A
  type Hom[F[_], A, B] = F[A] => F[B]
  type Prod[F[_], G[_], A, B] = F[(G[A], G[B])]
  type Kleisli[F[_], A, B] = A => F[B]

  final case class Functor[F[_]]
  (map: Hom[Id, ?, ?] ~~> Hom[F, ?, ?])
  final case class Pointed[F[_]]
  (map: Hom[Id, ?, ?] ~~> Hom[F, ?, ?],
   pure: Id ~> F)
  final case class Applicative[F[_]]
  (map: Hom[Id, ?, ?] ~~> Hom[F, ?, ?],
   pure: Id ~> F,
   zip: Prod[Id, F, ?, ?] ~~> Prod[F, Id, ?, ?])
  final case class Monad[F[_]]
  (map: Hom[Id, ?, ?] ~~> Hom[F, ?, ?],
   pure: Id ~> F,
   bind: Kleisli[F, ?, ?] ~~> Hom[F, ?, ?])
}