What is best way to wrap blocking Try[T] in Future[T] in Scala?

Question

Here is the problem, I have a library which has a blocking method return Try[T]. But since it's a blocking one, I would like to make it non-blocking using Future[T]. In the future block, I also would like to compute something that's depend on the origin blocking method's return value. But if I use something like below, then my `nonBlocking` will return Future[Try[T]] which is less convince since Future[T] could represent Failure[U] already, I would rather prefer propagate the exception to Future[T] is self. ``` def blockMethod(x: Int): Try[Int] = Try { // Some long operation to get an Int from network or IO throw new Exception("Network Exception") } } def nonBlocking(x: Int): Future[Try[Int]] = future { blockMethod(x).map(_ * 2) } ``` Here is what I tried, I just use `.get` method in `future {}` block, but I'm not sure if this is the best way to do that. ``` def blockMethod(x: Int): Try[Int] = Try { // Some long operation to get an Int from network or IO throw new Exception("Network E…

Accepted Answer

Here's an example that doesn't block, note that you probably want to use your own execution context and not scala's global context:

```
import scala.util._
import scala.concurrent._
import scala.concurrent.duration._
import ExecutionContext.Implicits.global

object Main extends App {

def blockMethod(x: Int): Try[Int] = Try {
    // Some long operation to get an Int from network or IO
    Thread.sleep(10000)
    100
  }

def tryToFuture[A](t: => Try[A]): Future[A] = {
    future {
      t
    }.flatMap {
      case Success(s) => Future.successful(s)
      case Failure(fail) => Future.failed(fail)
    }
  }

// Initiate long operation
  val f = tryToFuture(blockMethod(1))

println("Waiting... 10 seconds to complete")

// Should return before 20 seconds...
  val res = Await.result(f, 20 seconds)

println(res) // prints 100
}
```

What is best way to wrap blocking Try[T] in Future[T] in Scala?

Solution

Problem