4

Per the title, there are a couple of reasonable and idiomatic ways that I know of to return the first successful computation, though I'm most interested here in how to handle the case when we want to know the specific failure of the last attempt when all attempts fail. As a first attempt, we can use collectFirst and do something like the following:

  def main(args: Array[String]) {
    val xs = (1 to 5)
    def check(i: Int): Try[Int] = {
      println(s"checking: $i")
      Try(if (i < 3) throw new RuntimeException(s"small: $i") else i)
    }
    val z = xs.collectFirst { i => check(i) match { case s @ Success(x) => s } }
    println(s"final val: $z")
  }

This seems like a reasonable solution if we don't care about the failures (actually, since we're always returning a success, we never return a Failure, only a None in the case there is no successful computation).

On the other hand, to handle the case when all attempts fail, we can capture the last failure by using the following:

  def main2(args: Array[String]) {
    val xs = (1 to 5)
    def check(i: Int): Try[Int] = {
      println(s"checking: $i")
      Try(if (i < 3) throw new RuntimeException(s"small: $i") else i)
    }
    val empty: Try[Int] = Failure(new RuntimeException("empty"))
    val z = xs.foldLeft(empty)((e, i) => e.recoverWith { case _ => check(i) })
    println(s"final val: $z")
  }

The disadvantages here are that you create a "fake" Throwable representing empty, and if the list is very long, we iterate over the whole list, even though we may have succeeded very early on, even if later iterations are essentially no-ops.

Is there a better way to implement main2 that is idiomatic and doesn't suffer from the aforementioned disadvantages?

jonderry
  • 23,013
  • 32
  • 104
  • 171

2 Answers2

2

You could do something like this:

  @tailrec
  def collectFirstOrFailure[T](l: List[T], f: T => Try[T]): Try[T] = {
    l match {
      case h :: Nil =>  f(h)
      case h :: t =>  // f(h) orElse collectFirstOrFailure(t, f) //wish I could do this but not tailrec approved!
        val res = f(h)
        if (res.isFailure){
          collectFirstOrFailure(t, f)
        }
        else {
          res
        }
      case Nil => Failure(new RuntimeException("empty"))
    }
  }

  val y = collectFirstOrFailure(xs.toList, check)
  println(s"final val: $y")

This isn't very pretty, and we do still have to handle the empty list case, but we're not creating a new Failure(new RuntimeException("empty")) with every run (unless it's an empty list) and we stop short if there's a success. I feel like scalaz has some better way to do this but I can't figure it out right now. The returning the last failure requirement is making this a bit complex.

UPDATE

There's always iterator...

  def collectFirstOrFailureI[T](i: Iterator[T], f: T => Try[T]): Try[T] = {
    while (i.hasNext){
      val res = f(i.next())
      if (res.isSuccess || !i.hasNext){
        return res
      }
    }
    Failure(new RuntimeException("empty"))
  }

  xs.toIterator

  val x = collectFirstOrFailureI(xs.iterator, check)
  println(s"final val: $x")
Noah
  • 13,821
  • 4
  • 36
  • 45
  • It would be nice to do this on a `GenTraversableOnce` or something more generic, since the sequence may be infinite (assuming `toList` materializes the list). – jonderry Jun 25 '14 at 02:59
  • @jonderry the problem with making it more generic is the performance difference between different scala collections. I went with `Iterator` as it probably has the least performance impact. `GenTraversableOnce` really doesn't have the available properties to do this properly, though I guess you could just call `toIterator` off of it. – Noah Jun 25 '14 at 03:18
1

There's a previous answer:

https://stackoverflow.com/a/20665337/1296806

with the caveat that your question asks for the last failure, if all have failed.

I guess that's why this isn't a duplicate?

That's trivial to add to the code from that answer:

def bad(f: Failure) = if (count.decrementAndGet == 0) { p tryComplete new Failure(new RuntimeException("All bad", f.exception)) }

or more simply

p tryComplete f
Community
  • 1
  • 1
som-snytt
  • 39,429
  • 2
  • 47
  • 129