FunctionK Continuation

ContK.scala

import cats.~>

//what would happen if you tried to make a continuation based on natural transforms...
abstract class ContK[F[_], G[_], R]{ self =>
  def apply(fg: F ~> G): G[R]

  def map[B](f: R => B)(implicit fn: Functor[G]) = new ContK[F, G, B]{
    def apply(fg: F ~> G) = fn.map(self(fg))(f)
  }
  
  def ap[B](cont: ContK[F, G, R => B])(implicit ap: Apply[G]) = new ContK[F, G, B]{
    def apply(fg: F ~> G) = ap.ap(self(fg))(cont(fg))
  }
  
  def flatMap[B](f: R => ContK[F, G, B])(implicit b: Bind[G]) = new ContK[F, G, B]{
    def apply(fg: F ~> G) = b.flatMap(self(fg)){ f(_)(fg) }
  }

  def mapK[H[_]](fh: F ~> H) = new ContK[H, G, R]{
    def apply(hg: H ~> G) = self(fh andThen hg)
  }

  def flatMapK[H[_]](fc: F ~> ContK[H, G, ?]) = new ContK[H, G, R]{
  	def apply(hg: H ~> G) = self{ 
  	  λ[FunctionK[F, G]](fa => fc(fa)(gh))
  	}
  }
}

IndexedContK.scala

import cats.~>

//none of these are stack safe
abstract class IndexedContK[F[_], I[_], G[_], R]{ self =>
  def apply(fig: F ~> I): G[R]

  def map[B](f: R => B)(implicit fn: Functor[G]) = new IndexedContK[F, I, G, B]{
    def apply(fig: F ~> I) = fn.map(self(fig))(f)
  }
  
  def ap[B](cont: IndexedContK[F, I, G, R => B])(implicit ap: Apply[G]) = new IndexedContK[F, I, G, B]{
    def apply(fig: F ~> G) = ap.ap(self(fig))(cont(fig))
  }
  
  def flatMap[B](f: R => IndexedContK[F, I, G, B])(implicit b: Bind[G]) = new IndexedContK[F, I, G, B]{
    def apply(fig: F ~> I) = b.flatMap(self(fig)){ f(_)(fig) }
  }

  def mapK[H[_]](fh: F ~> H) = new IndexedContK[H, I, G, R]{
    def apply(hig: H ~> I) = self(fh andThen hig)
  }

  def flatMapK[H[_]](fc: F ~> IndexedContK[H, I, G, ?]) = new IndexedContK[H, I, G, R]{
  	def apply(hig: H ~> I) = self{ 
  	  λ[FunctionK[F, I]](fa => fc(fa)(hig))
  	}
  }
}