Scala tail recursion from finally block

Question

I want to apply a function f to each element of a List and not stop at the first error but throw the last error (if any) only:

@annotation.tailrec
def tryAll[A](xs: List[A])(f: A => Unit): Unit = {
  xs match {
    case x :: xt =>
      try {
        f(x)
      } finally {
        tryAll(xt)(f)
      }
    case _ =>
  }
}

But, the above code does not compile - it is complaining that this function is not tail recursive. Why not?

The function is not tail recursive since in the case an exception gets thrown, the `finally` block is not the last code to get executed. — Hristo Iliev, Feb 14 '17 at 16:05
@HristoIliev: I see - how can I write this in an efficient and idiomatic manner then? — pathikrit, Feb 14 '17 at 16:07
I believe the idiomatic way would be to use `scala.util.Try` to wrap the function invocations, but I'm unable to provide you with a sample code. — Hristo Iliev, Feb 14 '17 at 16:21
@mychemicalro: The point is not about removing the tailrec but understanding why this is not tail recursive. Also removing the annotation would cause StackOverflow for lists > 1M — pathikrit, Feb 14 '17 at 18:02

Yuval Itzchakov · Accepted Answer · 2017-02-14T16:28:20.750

1

This solution iterates over all elements and produces (throws) the last error if any:

def tryAll[A](xs: List[A])(f: A => Unit): Unit = {
  val res = xs.foldLeft(Option.empty[Throwable]) {
    case (maybeThrowable, a) =>
      Try(f(a)) match {
        case Success(_) => maybeThrowable
        case Failure(e) => Option(e)
      }
  }

  res.foreach(throwable => throw throwable)
}

edited Feb 14 '17 at 16:28

answered Feb 14 '17 at 16:21

Yuval Itzchakov

146,575
32
257
321

score 0 · Answer 2 · edited May 23 '17 at 12:09

As mentioned by @HristoIliev, your method cannot be tail recursive because the finally call is not guaranteed to be the tail call. This means that any method using try in this way will not be tail recursive. See this answer, also.

Calling the method again is a weird way of trying something repeatedly until it succeeds, because at each stage it's throwing an exception you are presumably not handling. Instead, I'd argue using a functional approach with Try, taking failures from a view until the operation succeeds. The only disadvantage to this approach is that it doesn't throw any exceptions for you to handle along the way (which can also be an advantage!).

def tryAll[A](xs: List[A])(f: A => Unit): Unit =
    xs.view.map(x => Try(f(x))).takeWhile(_.isFailure).force


scala> val list = List(0, 0, 0, 4, 5, 0)

scala> tryAll(list)(a => println(10 / a))
2

If you really want to handle the exceptions (or just the last exception), you can change the return type of tryAll to List[Try[Unit]] (or simply Try[Unit] if you modify the code to only take the last one). It's better for the return type of the method to describe part of what it's actually doing--potentially returning errors.

score -1 · Answer 3 · answered Feb 14 '17 at 16:15

Not sure the intention of the method, but you can something like that:

  final def tryAll[A](xs: List[A])(f: A => Unit): Unit = {
      xs match {
        case x :: xt =>
          try {
            f(x)
          } catch {
            case e => tryAll(xt)(f)
          }
        case _ => //do something else
      }
    }

mychemicalro · Answer 4 · 2017-02-14T18:40:23.667

-1

I know this way to use @annotation.tailrec

From this:

def fac(n:Int):Int = if (n<=1) 1 else n*fac(n-1)

You should have this:

@scala.annotation.tailrec 
def facIter(f:Int, n:Int):Int = if (n<2) f else facIter(n*f, n-1) 
def fac(n:Int) = facIter(1,n)

edited Feb 14 '17 at 18:40

answered Feb 14 '17 at 17:09

mychemicalro

232
3
21

You have to accumulate values in f, so when you reach the base case, return it. It does not make sense for your method :/ – mychemicalro Feb 14 '17 at 18:44

Scala tail recursion from finally block

4 Answers4