在函数式语言中，编译器如何能够将非尾递归转换为循环以避免堆栈溢出（如果有的话）？

Question

我最近一直在学习函数式语言，有多少不包含for循环。 虽然我个人并不认为递归比for循环更难（并且通常更容易推理），但我意识到许多递归的例子不是尾递归的，因此不能使用简单的尾递归优化来避免堆栈溢出。 根据这个问题 ，所有迭代循环都可以转换为递归，并且那些迭代循环可以转换为尾递归，所以当像这样的问题的答案表明你必须明确地管理你的递归的转换时，它会让我感到困惑。如果你想避免堆栈溢出，你自己的尾递归。 看起来编译器应该可以进行从递归到尾递归的所有转换，或者从递归直接到没有堆栈溢出的迭代循环。

功能编译器是否能够在更一般的递归情况下避免堆栈溢出？ 您是否真的被迫转换递归代码以避免堆栈溢出？ 如果他们无法执行一般的递归堆栈安全编译，为什么不呢？

Answer 1

尾调用优化：

进行参数和调用的自然方法是在退出或返回时清理清理。

要使尾部调用工作，您需要更改它以使尾部调用继承当前帧。 因此，它不是创建一个新的框架，而是按摩框架，以便下一个调用返回到当前函数调用者而不是此函数，如果它是尾部调用，它实际上只会清理并返回。

因此，TCO就是在最后一次通话之前清理。

延续传球风格 - 让所有事情都能打出尾巴

编译器可以更改代码，使其仅执行基本操作并将其传递给continuation。 因此，堆栈使用被移动到堆上，因为要继续的计算是一个函数。

一个例子是：

function hypotenuse(k1, k2) {
  return sqrt(add(square(k1), square(k2)))
}

变

function hypotenuse(k, k1, k2) {
  (function (sk1) {
    (function (sk2) {
      (function (ar) {
         k(sqrt(ar));
      }(add(sk1,sk2));
    }(square(k2));
  }(square(k1));
}

请注意，每个函数现在只有一个调用，并且设置了评估顺序。

Answer 2

任何递归函数都可以转换为尾递归函数。 例如，考虑图灵机的转换功能，即从配置到下一个配置的映射。 要模拟图灵机，您只需要迭代过渡函数，直到达到最终状态，这很容易用尾递归形式表示。 类似地，编译器通常将递归程序转换为迭代程序，只需添加一堆激活记录。

您还可以使用延续传递样式（CPS）将尾部递归形式转换为尾部递归形式。 为了得到一个经典的例子，考虑斐波纳契函数。 这可以通过以下方式以CPS样式表示，其中第二个参数是continuation（实质上是回调函数）：

def fibc(n, cont):
    if n <= 1:
        return cont(n)
    return fibc(n - 1, lambda a: fibc(n - 2, lambda b: cont(a + b)))

再次，您使用动态数据结构模拟递归堆栈：在本例中，lambda抽象。

在所有先前的示例中使用动态结构（列表，堆栈，函数等）是必不可少的。 也就是说，为了迭代地模拟泛型递归函数，你无法避免动态内存分配，因此通常无法避免堆栈溢出。

因此，内存消耗不仅与程序的迭代/递归性质有关。 另一方面，如果你阻止动态内存分配，你的程序本质上是有限的状态机，具有有限的计算能力（更有趣的是根据输入的维度参数化内存）。

通常，以无法预测终止的方式，您无法预测程序的未绑定内存消耗：使用图灵完整语言，在编译时您无法避免分歧，并且您无法避免堆栈溢出。

Answer 3

根据这个问题，所有迭代循环都可以转换为递归

“翻译”可能有点延伸。 如果您了解图灵完整性，那么对于每个迭代循环都有一个等效的递归程序的证明是微不足道的：因为图灵机可以使用严格的迭代结构和严格的递归结构来实现，所以可以用迭代语言表达的每个程序都可以表达用递归语言，反之亦然。 这意味着，对于每一迭代循环存在等效递归构建体（和周围的其他方法）。 然而，这并不意味着我们有一些自动化的方式将一个转换为另一个。

并且那些迭代循环可以转换为尾递归

尾递归也许可以很容易地转换成迭代循环，反之亦然。 但并非所有递归都是尾递归。 这是一个例子。 假设我们有一些二叉树。 它由node组成。 每个node可以有一个left ， right子项和一个value 。 如果节点没有子节点，则isLeaf为它返回true。 我们假设有一些函数max返回两个值的最大值，如果其中一个值为null则返回另一个值。 现在我们要定义一个函数，该函数在所有叶节点中找到最大值。 这是我编写的一些伪代码。

findmax(node) {
    if (node == null) {
        return null
    }
    if (node.isLeaf) {
        return node.value
    } else {
        return max(findmax(node.left), findmax(node.right))
    }
}

max函数中有两个递归调用，因此我们无法优化尾递归。 在我们将它们提供给max函数并确定当前节点的调用结果之前，我们需要两者的结果。

现在，可能有一种方法可以获得相同的结果，使用递归和只有一个尾递归调用。 它在功能上是等价的，但它是一种不同的算法。 编译器可以进行大量的转换来创建一个具有大量优化功能的等效程序，但是它们不够聪明，无法创建功能等同的算法。

即使只是递归地将自身调用一次到尾递归版本的函数的转换也远非微不足道。 这种适应通常使用一些参数传递给递归调用，该参数用作当前结果的“累加器”。

查看用于计算数字阶乘的下一个简单实现（例如，事实（5）= 5 * 4 * 3 * 2 * 1）：

fact(number) {
    if (number == 1) {
        return 1
    } else {
        return number * fact(number - 1)
    }
}

它不是尾递归的。 但它可以这样做：

fact(number, acc) {
    if (number == 1) {
        return acc
    } else {
        return fact(number - 1, number * acc)
    }
}
// Helper function
fact(number) {
    return fact(number, 1)
}

这需要解释正在做的事情。 认识到像这样的东西的情况很容易，但如果你调用函数而不是乘法怎么办？ 编译器如何知道初始调用时累加器必须为1而不是0？ 你是如何翻译这个程序的？

recsub(number) {
    if (number == 1) {
        return 1
    } else {
        return number - recsub(number - 1)
    }
}

这已经超出了我们现在所拥有的那种编译器的范围，实际上可能总是如此。

也许在计算机科学Stack Exchange上询问它是否有趣，看看他们是否知道一些更深入地研究这些的论文或证据。