dkomanov

def stackTrace(implicit ec: ExecutionContext): Any = {
  Await.result(
    Future.successful(1)
      .map(v => v + 1)
      .flatMap(v => Future.successful(v))
      .map { v =>
        new IllegalStateException().printStackTrace()
        v
      },
    10.seconds

dkomanov

class RpcClient(ownEc: ExecutionContext, appEc: ExecutionContext) {
  def call: Future[String] =
    Future("a")(ownEc)
      .map(identity)(appEc) // here we move back to an application execution context
}

dkomanov

def rpcCall: Future[String]
def daoCall(id: String): Future[Int]
def extractId(idStr: String): Future[String]
def convertDbValue(value: Int): Future[Int]

import directExecutionContext

for {
  idStr <- rpcCall
  id <- extractId(idStr) // executed in RPC execution context

dkomanov

def map[U](f: T => U)
          (implicit ec: ExecutionContext): Future[U] = {
  val promise = Promise()
  if (isCompleted) // in real code this is an atomic operation + pattern matching
    // even if it's completed, callback is submitted to ExecutionContext
    ec.execute(() => {
      f(result)
    })
  else
    registerCallback(f)(ec)

dkomanov

def smartMap[U](f: T => U)(implicit ec: ExecutionContext): Future[U] =
  if (future.isCompleted) {
    if (future.value.get.isSuccess)
      wrap(f(future.value.get.get))
    else
      future.asInstanceOf[Future[U]]
  } else {
    future.map(f)(ec)
  }

dkomanov

var future = Future.successful(0)
for (_ <- 1 to 100) {
  future = future.map(v => v + 1)
}
require(Await.result(future, 10.seconds) == 100)

dkomanov

def rpcCall: Future[String] = ???

rpcCall
  .map(_.split('_'))
  .filter(_.length < 4)
  .map {
    case Array(single) => single
    case Array(first, second@_) => first
    case Array(first@_, second, third@_) => third
    case _ => ""

dkomanov

class RobustDao(jdbcTemplate: JdbcTemplate,
                blockingEc: ExecutionContext,
                applicationEc: ExecutionContext) {
  def get(id: String): Future[Option[RichDomainObject]] = {
    Future(getBlocking(id))(blockingEc)
      .map(blob => blob.map(parseJson))(applicationEc)
  }

  private def getBlocking(id: String): Option[String] =
    jdbcTemplate.queryForObject(

dkomanov

trait ExecutionContext {
  def execute(runnable: Runnable): Unit
  def reportFailure(cause: Throwable): Unit
}

dkomanov

implicit val blockingExecutionContext =
  ExecutionContext.fromExecutorService(Executors.newFixedThreadPool(50))

class MyDao(jdbcTemplate: JdbcTemplate)(implicit ec: ExecutionContext) {
  def get(id: String): Future[Option[RichDomainObject]] =
    Future(getBlocking(id))

  private def getBlocking(id: String): Option[RichDomainObject] =
    jdbcTemplate.queryForObject(
      "SELECT blob FROM table WHERE id = ?",