如何将此二进制递归函数转换为尾递归形式？

Question

有一种明确的方法可以将二进制递归转换为尾递归，用于在函数下关闭的集合，即斐波那契数列的加法整数：

（使用 Haskell）

fib :: Int -> Int
fib n = fib' 0 1 n

fib' :: Int -> Int -> Int
fib' x y n
    | n < 1 = y  
    | otherwise = fib' y (x + y) (n - 1)

之所以可行，是因为我们有我们想要的值 y 和我们的操作 x + y，其中 x + y 返回一个整数，就像 y 一样。

但是，如果我想使用一个在函数下没有闭合的集合怎么办？我想采用一个函数，将一个列表拆分为两个列表，然后对这两个列表执行相同操作（即，像递归地创建二叉树），当另一个函数神奇地说何时停止查看结果拆分时，我会停止：

[1, 2, 3, 4, 5] -> [[1, 3, 4], [2, 5]] -> [[1, 3], [4], [2], [5]]

也就是说，

splitList :: [Int] -> [[Int]]
splitList intList
    | length intList < 2    = [intList]
    | magicFunction x y > 0 = splitList x ++ splitList y
    | otherwise             = [intList]
  where
    x = some sublist of intList
    y = the other sublist of intList

现在，如何将此二进制递归转换为尾递归？先前的方法不会显式工作，因为（Int + Int -> Int 与输入相同）但（Split [Int] -/> [[Int]] 与输入不同）。因此，累加器需要更改（我假设）。

Answer 1

您通常不希望在 Haskell 中使用 tail-recursion。您真正想要的是生产性核心递归（另请参阅this），描述SICP 中所谓的迭代过程。

您可以通过将初始输入包含在列表中来修复函数中的类型不一致。在你的例子中

[1, 2, 3, 4, 5] -> [[1, 3, 4], [2, 5]] -> [[1, 3], [4], [2], [5]]

只有第一个箭头不一致，所以改成

[[1, 2, 3, 4, 5]] -> [[1, 3, 4], [2, 5]] -> [[1, 3], [4], [2], [5]]

它说明了迭代应用concatMap splitList1的过程，其中

   splitList1 xs 
      | null $ drop 1 xs = [xs]
      | magic a b > 0    = [a,b]    -- (B)
      | otherwise        = [xs]
     where (a,b) = splitSomeHow xs

如果在某个迭代中没有触发 (B) 案例，您想停止。

（编辑：删除中间版本）

但最好尽快生成准备好的输出部分：

splitList :: [Int] -> [[Int]]
splitList xs = g [xs]   -- explicate the stack
  where
    g []                  = []
    g (xs : t)
       | null $ drop 1 xs = xs : g t
       | magic a b > 0    = g (a : b : t)
       | otherwise        = xs : g t
     where (a,b) = splitSomeHow xs 
           -- magic a b = 1
           -- splitSomeHow = splitAt 2

不要忘记使用-O2 标志进行编译。

Answer 2

有一个使 any 函数尾递归的通用技巧：以连续传递样式 (CPS) 重写它。 CPS 背后的基本思想是每个函数都有一个额外的参数——一个在完成时调用的函数。然后，原始函数不返回值，而是调用传入的函数。后一个函数称为“延续”，因为它继续将计算进行到下一步。

为了说明这个想法，我将使用您的函数作为示例。注意类型签名以及代码结构的变化：

splitListCPS :: [Int] -> ([[Int]] -> r) -> r
splitListCPS intList cont
  | length intList < 2    = cont [intList]
  | magicFunction x y > 0 = splitListCPS x $ \ r₁ -> 
                              splitListCPS y $ \ r₂ -> 
                                cont $ r₁ ++ r₂
  | otherwise             = cont [intList]

然后您可以将其包装成一个看起来很正常的函数，如下所示：

splitList :: [Int] -> [[Int]]
splitList intList = splitListCPS intList (\ r -> r)

如果你遵循稍微复杂的逻辑，你会发现这两个函数是等价的。棘手的一点是递归情况。在那里，我们立即用x 调用splitListCPS。函数\ r₁ -> ... 告诉splitListCPS 完成后要做什么——在这种情况下，使用下一个参数(y) 调用splitListCPS。最后，一旦我们得到两个结果，我们只需将结果合并并将其传递到原始延续 (cont)。所以最后，我们得到了与最初相同的结果（即splitList x ++ splitList y），但我们没有返回它，而是使用延续。

此外，如果您查看上面的代码，您会注意到所有递归调用都位于尾部位置。在每一步，我们的最后一个操作总是递归调用或使用延续。使用聪明的编译器，这种代码实际上可以相当高效。

在某种意义上，这个技术其实和你为fib做的很相似；然而，我们不是维护一个累加器值，而是维护一个我们正在执行的计算的累加器。