Execute.scala

import cats.effect.Async
import cats.implicits._

import scala.concurrent.{ExecutionContext, Future}
import scala.util.{Failure, Success}

/** Typeclass to wrap Scala futures. */
trait Execute[F[_]] {

  implicit def async: Async[F]

  def executionContext: F[ExecutionContext]

  def deferFutureAction[T](f: ExecutionContext => Future[T]): F[T] =
    executionContext.flatMap { implicit ec =>
      async.async { callback =>
        f(ec).onComplete {
          case Success(r) => callback(Right(r))
          case Failure(ex) => callback(Left(ex))
        }
      }
    }

  def deferFuture[T](future: => Future[T]): F[T] =
    deferFutureAction(_ => future)

}

object Execute  {

  def apply[F[_]: Execute]: Execute[F] =
    implicitly[Execute[F]]

  implicit def asyncExecute[F[_]: Async](implicit ec: ExecutionContext): Execute[F] =
    new Execute[F] {
      override def async: Async[F] = Async[F]
      override def executionContext: F[ExecutionContext] = ec.pure[F]
    }

}