Always annotate your tail-recursive function with
@annotation.tailrec.
This will let the compiler know that you expect your function to be tail-recursive, and allow compilation to fail should it not be.
This is important, because there are scenarios where you’d expect a function to be tail-recursive but it really isn’t. Take, for example:
class Foo {
def sum(cur: List[Int], acc: Int): Int = cur match {
case h :: t => sum(t, acc + h)
case _ => acc
}
}
This looks tail-recursive - sum calls itself in tail position, after all. Turns out, however, that it’s not:
class Foo {
@annotation.tailrec
def sum(cur: List[Int], acc: Int): Int = cur match {
case h :: t => sum(t, acc + h)
case _ => acc
}
}
// error: could not optimize @tailrec annotated method sum: it is neither private nor final so can be overridden
// final def sum(cur: List[Int], acc: Int): Int = cur match {
// ^
Thanks to that error message, we can fix the problem and make sum propery tail-recursive:
class Foo {
@annotation.tailrec
final def sum(cur: List[Int], acc: Int): Int = cur match {
case h :: t => sum(t, acc + h)
case _ => acc
}
}