First draft of a functional-style RetryPolicy implementation.

Main.scala

import scala.concurrent._
import scala.concurrent.duration._
import java.net.SocketTimeoutException

object Postgres {
  // Example for postgres connection timeout retry policy
  case class PgConnectionPolicy(n: Int) extends RetryPolicy {
    override def attempt(rpc: => Future[T]) = (PgConnectionPolicy(n - 1), rpc)
    override def retryable[E <: Throwable] = {
      case _: SocketTimeoutException => n > 0
      case _ => false
    }
  }
}

object Main extends App {
  import ExecutionContext.Implicits.global
  import RetryPolicy._
  val req = AsyncRetry(UntilNFailures(2)) {
    // some RPC call    
  }
  Await.result(req, 15.seconds)
}

RetryPolicy.scala

trait RetryPolicy {
  def attempt[T](rpc: => Future[T]): (RetryPolicy, Future[T])
  def retryable[E <: Throwable]: E => Boolean
}

object RetryPolicy {
  case class UntilNFailures(n: Int) extends RetryPolicy {
    override def attempt[T](rpc: => Future[T]) = (UntilNFailures(n - 1), rpc)
    override def retryable[E <: Throwable] = _ => n > 0
  }
}

// Helps split up our async utils
object AsyncRetry {
  def apply[T](policy: RetryPolicy)(rpc: => Future[T])(implicit ec: ExecutionContext): Future[T] = {
    val (nextPolicy, response) = policy.attempt(rpc)
    response.recoverWith {
      case e if nextPolicy.retryable(e) => apply(nextPolicy)(rpc)
      case e => Future.failed(e)
    }
  }  
}

Fantastic code. The type of work only a seasoned professional engineer could do. Nit: prefer retryable