Java Future to Cats Effect F[_]

JFuture.scala

import java.util.concurrent.Future

import cats.effect.{Effect, Sync, Timer}
import cats.syntax.all._
import fs2._
import fs2.async.mutable.Signal

import scala.concurrent.ExecutionContext
import scala.concurrent.duration._

class JFuture[F[_]](implicit F: Effect[F], S: Scheduler, ec: ExecutionContext) {

  private val PollInterval = 40.millis

  private def jFutureToF[A](fa: F[Future[A]])(signal: Signal[F, Boolean]): F[A] = {
    def check(future: Future[A]): F[Unit] =
      S.awakeEvery[F](PollInterval)
        .evalMap(_ => signal.modify(_ => future.isDone))
        .repeat
        .interruptWhen(signal)
        .compile.drain

    for {
      future <- fa
      _      <- check(future)
      effect <- F.delay(future.get())
    } yield effect
  }

  def from[A](fa: F[Future[A]]): F[A] =
    for {
      signal <- async.signalOf[F, Boolean](false)
      ioa    <- jFutureToF[A](fa)(signal)
    } yield ioa

}

object JFuture {

  def to[F[_], A](fa: F[Future[A]], pollInterval: FiniteDuration = 50.millis)
                 (implicit F: Sync[F], T: Timer[F]): F[A] = {
    def loop(jf: Future[A]): F[A] =
      F.delay(jf.isDone).flatMap { isDone =>
        if (isDone) F.delay(jf.get)
        else T.sleep(pollInterval) *> loop(jf)
      }

    fa.flatMap(loop)
  }

}