Soft Cancellation, moving cancellation into a Supervisor so you can cancel in flow, but not cancel what is happening.

SoftCancel.scala

package io.chrisdavenport.softcancel

import cats.effect._
import cats.effect.std._
import cats.syntax.all._

object SoftCancel {

  def makeSoftCancelable[F[_]: Concurrent, A](fa: F[A], supervisor: Supervisor[F]): F[A] = {
    supervisor.supervise(fa)
    .flatMap(_.joinWith(Concurrent[F].raiseError(new java.util.concurrent.CancellationException("Outcome was Canceled"))))
  }
}

object syntax {
  object all extends all

  trait all extends supervisor

  object supervisor extends supervisor
  trait supervisor {
    implicit class SupervisorSoftCancel[F[_]](private val s: Supervisor[F]){
      def makeSoftCancelable[A](fa: F[A])(implicit F: Concurrent[F]): F[A] = 
        SoftCancel.makeSoftCancelable(fa, s)
    }
  }
}