What's the Scala way to implement a retry-able call like this one?

Question

Still the newbie in Scala and I'm now looking for a way to implement the following code on it:

@Override public void store(InputStream source, String destination, long size) {      ObjectMetadata metadata = new ObjectMetadata();     metadata.setContentLength(size);     final PutObjectRequest request = new PutObjectRequest(             this.configuration.getBucket(), destination, source, metadata);      new RetryableService(3) {          @Override         public void call() throws Exception {             getClient().putObject(request);         }     };  } 

What would be the best way to implement the same funcionality that RetryableService implements but in Scala?

It basically calls the call method N times, if all of them fail the exception is then raised, if they succeed it moves on. This one does not return anything but then I have another version that allows for returning a value (so, i have two classes in Java) and I believe I could do with a single class/function in Scala.

Any ideas?

EDIT

Current implementation in java is as follows:

public abstract class RetryableService {  private static final JobsLogger log = JobsLogger         .getLogger(RetryableService.class);  private int times;  public RetryableService() {     this(3); }  public RetryableService(int times) {     this.times = times;     this.run(); }  private void run() {      RuntimeException lastExceptionParent = null;      int x = 0;      for (; x < this.times; x++) {          try {             this.call();             lastExceptionParent = null;             break;         } catch (Exception e) {             lastExceptionParent = new RuntimeException(e);             log.errorWithoutNotice( e, "Try %d caused exception %s", x, e.getMessage() );              try {                 Thread.sleep( 5000 );             } catch (InterruptedException e1) {                 log.errorWithoutNotice( e1, "Sleep inside try %d caused exception %s", x, e1.getMessage() );             }          }      }      try {         this.ensure();     } catch (Exception e) {         log.error(e, "Failed while ensure inside RetryableService");     }      if ( lastExceptionParent != null ) {         throw new IllegalStateException( String.format( "Failed on try %d of %s", x, this ), lastExceptionParent);     }     }  public void ensure() throws Exception {     // blank implementation }  public abstract void call() throws Exception;  } 

Answer 1

Recursion + first class functions by-name parameters == awesome.

def retry[T](n: Int)(fn: => T): T = {   try {     fn   } catch {     case e =>       if (n > 1) retry(n - 1)(fn)       else throw e   } } 

Usage is like this:

retry(3) {   // insert code that may fail here } 

Edit: slight variation inspired by @themel's answer. One fewer line of code :-)

def retry[T](n: Int)(fn: => T): T = {   try {     fn   } catch {     case e if n > 1 =>       retry(n - 1)(fn)   } } 

Edit Again: The recursion bothered me in that it added several calls to the stack trace. For some reason, the compiler couldn't optimize tail recursion in the catch handler. Tail recursion not in the catch handler, though, optimizes just fine :-)

@annotation.tailrec def retry[T](n: Int)(fn: => T): T = {   val r = try { Some(fn) } catch { case e: Exception if n > 1 => None }   r match {     case Some(x) => x     case None => retry(n - 1)(fn)   } } 

Edit yet again: Apparently I'm going to make it a hobby to keep coming back and adding alternatives to this answer. Here's a tail-recursive version that's a bit more straightforward than using Option, but using return to short-circuit a function isn't idiomatic Scala.

@annotation.tailrec def retry[T](n: Int)(fn: => T): T = {   try {     return fn   } catch {     case e if n > 1 => // ignore   }   retry(n - 1)(fn) } 

Scala 2.10 update. As is my hobby, I revisit this answer occasionally. Scala 2.10 as introduced Try, which provides a clean way of implementing retry in a tail-recursive way.

// Returning T, throwing the exception on failure @annotation.tailrec def retry[T](n: Int)(fn: => T): T = {   util.Try { fn } match {     case util.Success(x) => x     case _ if n > 1 => retry(n - 1)(fn)     case util.Failure(e) => throw e   } }  // Returning a Try[T] wrapper @annotation.tailrec def retry[T](n: Int)(fn: => T): util.Try[T] = {   util.Try { fn } match {     case util.Failure(_) if n > 1 => retry(n - 1)(fn)     case fn => fn   } } 

Answer 2

There is a method in scalaz.concurrent.Task[T]: http://docs.typelevel.org/api/scalaz/nightly/#scalaz.concurrent.Task

def retry(delays: Seq[Duration], p: (Throwable) ⇒ Boolean = _.isInstanceOf[Exception]): Task[T] 

Given a Task[T], you can create a new Task[T] which will retry a certain number of times, where the delay between retries is defined by the delays parameter. e.g.:

// Task.delay will lazily execute the supplied function when run val myTask: Task[String] =   Task.delay(???)  // Retry four times if myTask throws java.lang.Exception when run val retryTask: Task[String] =   myTask.retry(Seq(20.millis, 50.millis, 100.millis, 5.seconds))  // Run the Task on the current thread to get the result val result: String = retryTask.run