- Concepts of Programming Languages

Tail Recursion

Instructor:

Fibonacci Numbers

• In Scala 3 new syntax, implement a recursive function to compute the Fibonacci numbers

• def fibonacci(n: Int): Int = n match
    case 0 => 0
    case 1 => 1
    case _ => fibonacci(n - 1) + fibonacci(n - 2)
  

• Try fibonacci(30) and fibonacci(45)

Fibonacci Numbers

• Make it fast

• def fibonacci(n: Int, memo: mutable.Map[Int, Int] = mutable.Map.empty): Int =
    if n <= 0 then return 0
    if n == 1 then return 1
    if memo.contains(n) then return memo(n)
    // Calculate Fibonacci and store in the map
    val result = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    memo(n) = result
    result  
  

• Applies dynamic programming
• Do we need to keep all the numbers ever computed?
• Does it truly solve the problem?

Learning Objectives

How to get recursive iteration without stack penalty and without recomputing intermediate results?

• Identify and express tail recursion

Recursion and Stack Limitations

def sum (xs:List[Int]) : Int =  xs match 
  case Nil     => 0
  case x::rest => x + sum (rest)
val xs = List(11,21,31)
sum (xs)

• Summing up left to after the last recursive call returns
• How does the stack look like?

Call Stack

• Contains activation records (AR) for active calls, also known as stack frames
• Changes to call stack
  • AR pushed when a function/method call is made
  • AR popped when a function/method returns

• Runtime environments limit size of call stacks?
• Can cause problems with deep recursion
  • Java, Scala: StackOverflowError
  • C: stack limits set by operating system

Tail Recursive Calls

Sum of elements in a list computing forward

def sum (xs:List[Int], z:Int = 0) : Int =  xs match 
  case Nil     => z
  case x::rest => sum (rest, z + x)

• All recursive calls are in tail-position
• Result sum computed before recursive call is made, no work left
• How is the stack now different?

Tail-Call Optimization: Rewrite to Loop

def sum (xs:List[Int], z:Int = 0) : Int = 
  xs match
    case Nil     => z
    case x::rest => sum (rest, z+x)

def sum (xs: List[Int]) : Int =
  var z = 0
  def loop (xs: List[Int]) : Int = 
    xs match
      case Nil     => z
      case x::rest => 
        z = z + x
        loop(rest)
  end loop
  loop(xs)

def sum (xs: List[Int]) : Int =
  var z = 0
  var l = xs
  def loop () : Int = 
    l match
      case Nil     => z
      case x::rest => 
        z = z + x
        l = rest
        loop()
  end loop
  loop()

def sum (xs: List[Int]) : Int =
  var z = 0
  var l = xs
  def loop () : Int = 
    if l == Nil then z
    else 
      z = z + l.head
      l = l.tail
      loop()
  end loop
  loop()

def sum (xs: List[Int]) : Int =
  var z = 0
  var l = xs
  while l != Nil do
    z = z + l.head
    l = l.tail
  end while
  z

Tail Call Optimization

• Many compilers implement tail-call optimization
  • overwrite existing activation record instead of creating new
• Recursive calls must be tail-recursive
• Includes mutual recursion
  • f calls to g, which calls back to f

Exercise: Recursive vs. Tail-Recursive Fibonacci

def fib(n:Int) : Long =
  if n <= 1 then n
  else fib(n-1) + fib(n-2)

Tail-recursive Fibonacci Numbers

• In Scala 3, implement a tail-recursive function to compute Fibonacci numbers

• def fibonacci(n: Int): Int =
    @tailrec
    def fibHelper(n: Int, a: Int, b: Int): Int = n match
      case 0 => a
      case _ => fibHelper(n - 1, b, a + b)
    end fibHelper
    fibHelper(n, 0, 1)
  end fibonacci
  

• tailrec annotation: compiler error if not tail-recursive
• Specific instructions help generate good code

Continuation Passing

• Can all functions be made tail-recursive?

• Continuation passing: add an extra argument for a function to take the "return" value

def sum (xs:List[Int], z:Int = 0) : Int = 
  xs match
    case Nil     => z
    case x::rest => sum (rest, z+x)
end sum
var s = sum(List(1,2,3))

def sum (xs:List[Int], c:Int=>Unit) : Unit = 
  xs match
    case Nil     => c(0)
    case x::rest => sum (rest, y=>c(x+y))
end sum
var s = -1
sum(List(1,2,3), s=_)

• Continuation passing is used by compilers of functional languages as an intermediate form (similar to static single assignment in imperative languages)

Summary

• Tail-call optimization
  • avoids the performance penalty of creating activation records
  • overwrites an existing activation record
  • all recursive calls must be in tail position (last operation)
  • continuation passing replaces return value with a function that is called upon "return"

Tail-Call Optimization: Rewrite to Loop

def factorial (n:Int) : Int =
  @tailrec
  def loop (m:Int, result:Int) : Int =
    if m > 1 then loop(m-1, m*result)
    else result
  loop(n,1)

def factorial (n:Int) : Int =
  var result = 1
  def loop (m:Int) : Unit =
    if m > 1 then 
      result = result*m
      loop(m-1)
  loop(n)
  result

def factorial (n:Int) : Int =
  var result = 1
  var m = n
  def loop () : Unit =
    if m > 1 then 
      result = result*m
      m = m-1
      loop()
  loop()
  result

def factorial (n:Int) : Int =
  val result = 1
  var m = n
  while m > 1 do
    result = result * m
    m = m - 1
  result