为什么scala不进行尾调用优化？

Question

只是玩延续。目标是创建一个函数，该函数将接收另一个函数作为参数，以及执行量 - 和返回函数，该函数将应用参数给定的次数。

实现看起来很明显

def n_times[T](func:T=>T,count:Int):T=>T = {
  @tailrec
  def n_times_cont(cnt:Int, continuation:T=>T):T=>T= cnt match {
        case _ if cnt < 1 => throw new IllegalArgumentException(s"count was wrong $count")
        case 1 => continuation
        case _ => n_times_cont(cnt-1,i=>continuation(func(i)))
      }
  n_times_cont(count, func)
}

def inc (x:Int) = x+1

    val res1 = n_times(inc,1000)(1)  // Works OK, returns 1001

val res = n_times(inc,10000000)(1) // FAILS

但没有问题 - 此代码因 StackOverflow 错误而失败。为什么这里没有尾调用优化？

我使用 Scala 插件在 Eclipse 中运行它，它返回 线程“主”java.lang.StackOverflowError 中的异常 在 scala.runtime.BoxesRunTime.boxToInteger（未知来源） 在 Task_Mult$$anonfun$1.apply(Task_Mult.scala:25) 在 Task_Mult$$anonfun$n_times_cont$1$1.apply(Task_Mult.scala:18)

附言

几乎是直接翻译的 F# 代码可以正常工作

let n_times_cnt func count = 
    let rec n_times_impl count' continuation = 
        match count' with
        | _ when count'<1 -> failwith "wrong count"
        | 1 -> continuation
        | _ -> n_times_impl (count'-1) (func >> continuation) 
    n_times_impl count func

let inc x = x+1
let res = (n_times_cnt inc 10000000) 1

printfn "%o" res

Answer 1

Scala 标准库在scala.util.control.TailCalls 中实现了蹦床。所以重新审视你的实现......当你使用continuation(func(t)) 构建嵌套调用时，这些是尾调用，只是没有被编译器优化。所以，让我们建立一个T => TailRec[T]，其中堆栈帧将被堆中的对象替换。然后返回一个函数，该函数将接受参数并将其传递给该蹦床函数：

import util.control.TailCalls._
def n_times_trampolined[T](func: T => T, count: Int): T => T = {
  @annotation.tailrec
  def n_times_cont(cnt: Int, continuation: T => TailRec[T]): T => TailRec[T] = cnt match {
    case _ if cnt < 1 => throw new IllegalArgumentException(s"count was wrong $count")
    case 1 => continuation
    case _ => n_times_cont(cnt - 1, t => tailcall(continuation(func(t))))
  }
  val lifted : T => TailRec[T] = t => done(func(t))
  t => n_times_cont(count, lifted)(t).result
}

Answer 2

我在这里可能错了，但我怀疑n_times_cont 内部函数已正确转换为使用尾递归；罪魁祸首不在。

堆栈被收集的continuation 闭包（即i=>continuation(func(i))）炸毁，一旦您应用主函数的结果，就会对您的inc 方法进行10000000 次嵌套调用。

其实你可以试试

scala> val rs = n_times(inc, 1000000)
rs: Int => Int = <function1> //<- we're happy here

scala> rs(1) //<- this blows up the stack!

---

顺便说一句，你可以重写

i=>continuation(func(i))

作为

continuation compose func

为了更好的可读性