Monix Task's Async instance for Korolev

TaskAsync.scala

import korolev.Async
import korolev.Async.Promise
import monix.eval.Task
import monix.execution.Scheduler

import scala.util.{Failure, Success, Try}

class TaskAsync(implicit scheduler: Scheduler) extends Async[Task] {

  override val unit: Task[Unit] = Task.unit

  override def pure[A](value: A): Task[A] = Task.now(value)

  override def delay[A](value: => A): Task[A] = Task.eval(value)

  override def fork[A](value: => A): Task[A] = Task(value)

  override def fromTry[A](value: => Try[A]): Task[A] = Task.fromTry(value)

  override def promise[A]: korolev.Async.Promise[Task, A] = {
    val promise = scala.concurrent.Promise[A]()
    new Promise[Task, A] {
      val async: Task[A] = Task.fromFuture(promise.future)
      def complete(`try`: Try[A]): Unit = {
        promise.complete(`try`)
        ()
      }
      def completeAsync(async: Task[A]): Unit = {
        promise.completeWith(async.runToFuture)
        ()
      }
    }
  }

  override def flatMap[A, B](m: Task[A])(f: A => Task[B]): Task[B] = m.flatMap(f)

  override def map[A, B](m: Task[A])(f: A => B): Task[B] = m.map(f)

  override def recover[A](m: Task[A])(f: PartialFunction[Throwable, A]): Task[A] = m.onErrorRecover(f)

  override def sequence[A](in: List[Task[A]]): Task[List[A]] =
    Task.sequence(in)

  override def run[A, U](m: Task[A])(f: Try[A] => U): Unit = {
    m.runAsync { r => { f(r.fold(Failure(_), Success(_))); () } }
    ()
  }

}