在惰性求值的情况下，何时需要尾递归？

Question

我的理解（可能不正确或不完整）是 惰性求值 可以提供 尾递归 的所有优点，并且做得更好。

如果是这样，是否意味着在惰性求值的上下文中不需要尾递归？

更新

具体看下面的例子：

(define (foo f a)
  (if (number? a)
    (* a a)
    (lazy-map foo a)))

这个函数可以很容易地转换为尾递归函数。但是，如果是这样，我们将失去惰性求值的优势。

实际上，当输入是一个非常大的列表（或无限）时，这个非尾递归函数是否需要消耗很多堆栈？我不这么认为。那么，是否有充分的理由使用 尾递归 而不是 惰性求值？

Answer 1

TL;DR“尾递归”定义函数在惰性语言中通常没有用处。即使在这些情况下，您也可能会发生堆栈溢出（与具有适当尾调用优化的严格语言相反）。

通过对函数参数使用惰性求值（按名称调用），您将失去用递归表达简单迭代（使用常量空间）的能力。

例如，让我们比较两个版本的长度函数。首先我们看下非尾递归函数来比较惰性和非惰性：

length [] = 0
length (head:tail) = length tail + 1

严格评价length [1, 2, 3]：

length [1, 2, 3] ->
  length (1:[2, 3]) = length [2, 3] + 1 ->
    length (2:[3]) + 1 = (length [3] + 1) + 1 ->
      (length (3:[]) + 1) + 1 = ((length [] + 1) + 1) + 1 ->
        ((length [] + 1) + 1) + 1 = ((0 + 1) + 1) + 1 ->
      (1 + 1) + 1 ->
    2 + 1
  3

懒惰的评价：

length [1, 2, 3] ->
length (1:[2, 3]) = length [2, 3] + 1 ->

此时需要减少+，它需要评估两个参数，第一个是length [2, 3]，所以它像以前一样继续，但在一个少一个参数的列表上。 堆栈空间用于评估+（如果我们正在考虑一个简单的实现）。

因此，两个版本都使用堆栈，但对于懒惰的版本，+ 是这里的“递归”函数，而不是 +。

尾递归变体（使用累加器）：

length [] a = a
length (head:tail) a = length tail (a + 1)

利用尾调用优化的严格评估步骤：

length [1, 2, 3] 0 ->
length (1:[2, 3]) 0 = length [2, 3] (0 + 1) ->
length (2:[3]) 1 = length [3] (1 + 1) ->
length (3:[]) 2 = length [] 2 + 1 ->
length [] 3 = 3

这使用堆栈上的常量空间，堆上没有空间

懒惰的评价：

length [1, 2, 3] 0 ->
length (1:[2, 3]) 0 = length [2, 3] (0 + 1) ->
length (2:[3]) (0 + 1) = length [3] ((0 + 1) + 1) ->
length (3:[]) ((0 + 1) + 1) = length [] ((0 + 1) + 1) + 1 ->
length [] (0 + 1) + 1) + 1 = ((0 + 1) + 1) + 1 ->
magic -> 3

这使用堆栈上的恒定空间直到“魔术”部分，但在堆上建立延迟计算（加法）（通常）。标记为“魔术”的部分是所有的总和发生的地方，在简单的实现中它使用堆栈。 （请注意，在这种情况和类似情况下，优化评估器实际上可能会在评估期间进行加法运算，然后只返回 3，您无法真正分辨出区别，但没有使用堆栈。它可以使用其他技巧来防止堆栈溢出像 CPS）。

总结：

惰性求值函数最终在其直接实现中使用堆栈，无论它们是否编写为尾递归。

但是，您需要对编译器应用各种技巧来优化堆栈使用。不过，它们不像严格语言中的尾调用优化那么简单。

更好的选择是习惯性地使用这些语言并利用各种高阶函数，从而显着减少对递归函数定义的需求（并且在某种程度上也是出于这个原因在惰性语言中）。