Attempt to implement ContT instances

core/src/main/scala/cats/mtl/Chronicle.scala

@@ -178,6 +178,16 @@ private[mtl] trait ChronicleInstances {
             case Ior.Right((l, s2, a)) => (l, s2, Ior.Right(a))
           })
     }
+
+  implicit def chronicleForContT[F[_]: Defer: Monad, E, C: Monoid](
+      implicit F: Chronicle[F, E]): Chronicle[ContT[F, C, *], E] =
+    new Chronicle[ContT[F, C, *], E] {
+      val monad: Monad[ContT[F, C, *]] =
+        MonadPartialOrder.monadPartialOrderForContT[F, C].monadG
+      def dictate(c: E): ContT[F, C, Unit] = ContT.liftF(F.dictate(c))
+      def confess[A](c: E): ContT[F, C, A] = ContT.liftF(F.confess[A](c))
+      def materialize[A](fa: ContT[F, C, A]): ContT[F, C, Ior[E, A]] = ???
+    }
 }
 
 object Chronicle extends ChronicleInstances {

core/src/main/scala/cats/mtl/Handle.scala

@@ -215,6 +215,21 @@ private[mtl] trait HandleInstances extends HandleLowPriorityInstances {
           f: E => RWST[F, R, L, S, A]): RWST[F, R, L, S, A] =
         RWST { case (r, s) => F0.handleWith(fa.run(r, s))(e => f(e).run(r, s)) }
     }
+
+  implicit def handleContT[F[_]: Defer, E, C](
+      implicit F0: Handle[F, E],
+      M: Monad[F]): Handle[ContT[F, C, *], E] =
+    new RaiseMonadPartialOrder[F, ContT[F, C, *], E] with Handle[ContT[F, C, *], E] {
+
+      val applicative: Applicative[ContT[F, C, *]] = ContT.catsDataContTMonad
+
+      val F: Raise[F, E] = F0
+      val lift: MonadPartialOrder[F, ContT[F, C, *]] =
+        MonadPartialOrder.monadPartialOrderForContT
+
+      def handleWith[A](fa: ContT[F, C, A])(f: E => ContT[F, C, A]): ContT[F, C, A] =
+        ContT(c => F0.handleWith(fa.run(c))(e => f(e).run(c)))
+    }
 }
 
 object Handle extends HandleInstances {

core/src/main/scala/cats/mtl/Listen.scala

@@ -17,9 +17,18 @@
 package cats
 package mtl
 
-import cats.data.{EitherT, StateT, IorT, Kleisli, OptionT, ReaderWriterStateT => RWST, WriterT}
+import cats.data.{
+  ContT,
+  EitherT,
+  Ior,
+  IorT,
+  Kleisli,
+  OptionT,
+  StateT,
+  WriterT,
+  ReaderWriterStateT => RWST
+}
 import cats.syntax.all._
-import cats.data.Ior
 
 import scala.annotation.implicitNotFound
 
@@ -75,7 +84,7 @@ private[mtl] abstract class ListenKleisli[F[_]: Functor, R, L](implicit F: Liste
   def functor = Functor[Kleisli[F, R, *]]
   def tell(l: L) = Kleisli.liftF(F.tell(l))
   def listen[A](fa: Kleisli[F, R, A]) =
-    Kleisli(a => F.listen(fa.run(a)))
+    Kleisli((a: R) => F.listen(fa.run(a)))
 }
 
 private[mtl] abstract class ListenStateT[F[_]: Applicative, S, L](implicit F: Listen[F, L])
@@ -148,6 +157,13 @@ private[mtl] abstract class ListenInductiveRWST[F[_]: Applicative, E, L0: Monoid
     }
 }
 
+private[mtl] abstract class ListenContT[F[_]: FlatMap, R, L](implicit F: Listen[F, L])
+    extends Listen[ContT[F, R, *], L] {
+  def functor: Functor[ContT[F, R, *]] = Functor.asInstanceOf[Functor[ContT[F, R, *]]]
+  def tell(l: L): ContT[F, R, Unit] = ContT.liftF[F, R, Unit](F.tell(l))
+  def listen[A](fa: ContT[F, R, A]): ContT[F, R, (A, L)] = ???
+}
+
 private[mtl] trait LowPriorityListenInstances {
 
   implicit def inductiveListenForWriterT[F[_]: Applicative, L, L0: Monoid](

core/src/main/scala/cats/mtl/MonadPartialOrder.scala

@@ -89,6 +89,13 @@ private[mtl] trait MonadPartialOrderInstances {
       val monadF: Monad[F] = F
       val monadG: Monad[IorT[F, E, *]] = IorT.catsDataMonadErrorForIorT[F, E]
     }
+
+  implicit def monadPartialOrderForContT[F[_]: Defer, C](implicit F: Monad[F]): MonadPartialOrder[F, ContT[F, C, *]] =
+    new MonadPartialOrder[F, ContT[F, C, *]] {
+      def apply[A](fa: F[A]): ContT[F, C, A] = ContT.liftF(fa)
+      val monadF: Monad[F] = F
+      val monadG: Monad[ContT[F, C, *]] = ContT.catsDataContTMonad[F, C]
+    }
 }
 
 object MonadPartialOrder extends MonadPartialOrderInstances {