Tail-Recursive Function (Coursera Issues) - scala

Question

I'm following a Coursera course for functional programming in Scala so that I can learn the language.
They introduced the concept of tail-recursive functions and defined them basically as a function that ends in a call to itself. But then they show this as the worked example:
def sum(f: Int => Int)(a: Int, b: Int): Int = {
def loop(a: Int, acc: Int): Int = {
if (a > b) acc
else loop(a + 1, f(a) + acc)
}
loop(a, 0)
}
If I annotate sum with #tailrec, I get an error because the IDE (IntelliJ) does not consider it to be tail recursive.
Is sum called tail-recursive here, or is the inner implementation "loop" the thing that is considered to be tail recursive in this case?

Answer 1

You're right. sum needs to call itself otherwise Scala will complain with:
#tailrec annotated method contains no recursive calls
If you tell compiler where exactly it is, by moving the #tailrec to where the tail recursion is:
def sum(f: Int => Int)(a: Int, b: Int): Int = {
#tailrec def loop(a: Int, acc: Int): Int = {
if (a > b) acc
else loop(a + 1, f(a) + acc)
}
loop(a, 0)
}
Then the compiler'll be satisfied it is tail-recursion optimised.

Answer 2

The inner loop method is tail-recursive, the sum method is not recursive at all. Therefore, you should annotate loop with #tailrec.
Moving loop to the outer scope may help visualize what's going on:
def sum(f: Int => Int)(a: Int, b: Int): Int = {
loop(a, 0)
}
def loop(a: Int, acc: Int): Int = {
if (a > b) acc
else loop(a + 1, f(a) + acc)
}
As you can see, sum is merely a public entry point for loop.
(Note that the code above won't compile because loop does not close over b or f anymore, but you get the point.)