Clojure：简单的阶乘导致堆栈溢出

Question

我做错了什么？几千次调用深度的简单递归会抛出StackOverflowError。

如果 Clojure 递归的限制这么低，我怎么能依赖它？

(defn fact[x]
  (if (<= x 1) 1 (* x  (fact (- x 1))  )))

user=> (fact 2)
2

user=> (fact 4)
24

user=> (fact 4000)
java.lang.StackOverflowError (NO_SOURCE_FILE:0)

Answer 1

据我所知，堆栈大小取决于您使用的 JVM 以及平台。如果您使用的是 Sun JVM，则可以使用 -Xss 和 -XThreadStackSize 参数来设置堆栈大小。

在 Clojure 中进行递归的首选方法是使用 loop/recur:

(defn fact [x]
    (loop [n x f 1]
        (if (= n 1)
            f
            (recur (dec n) (* f n)))))

Clojure 会为此进行尾调用优化；这样可以确保您永远不会遇到StackOverflowErrors。

由于defn implies a loop binding，您可以省略loop 表达式，并将其参数用作函数参数。要使其成为 1 参数函数，请使用 the multiary caracteristic of functions:

(defn fact
  ([n] (fact n 1))
  ([n f]
  (if (<= n 1)
    f
    (recur (dec n) (* f n)))))

编辑：为了记录，这里有一个 Clojure 函数，它返回所有阶乘的惰性序列：

(defn factorials []
    (letfn [(factorial-seq [n fact]
                           (lazy-seq
                             (cons fact (factorial-seq (inc n) (* (inc n) fact)))))]
      (factorial-seq 1 1)))

(take 5 (factorials)) ; will return (1 2 6 24 120)

Answer 2

要添加到 Siddhartha Reddy 的答案，您还可以借用 Factorial 函数形式 Structure And Interpretation of Computer Programs，并进行一些 Clojure 特定的调整。即使对于非常大的阶乘计算，这也给了我很好的性能。

(defn fac [n]
  ((fn [product counter max-count]
     (if (> counter max-count)
         product
         (recur (apply *' [counter product])
                (inc counter)
                max-count)))
   1 1 n))

Answer 3

另一个简单的递归实现可能是这样的：

(defn fac [x]
    "Returns the factorial of x"
    (if-not (zero? x) (* x (fac (- x 1))) 1))

Answer 4

Clojure 有几种方法破坏递归

带有 recur 的显式尾调用。 （它们必须是真正的尾调用，所以这不起作用）

惰性序列如上所述。

trampolining 在这里，您返回一个完成工作的函数，而不是直接执行它，然后调用一个蹦床函数，该函数重复调用其结果，直到它变成一个真正的值而不是一个函数。

(defn fact ([x] (trampoline (fact (dec x) x))) 
           ([x a] (if (<= x 1) a #(fact (dec x) (*' x a)))))
(fact 42)
620448401733239439360000N

memoizing 事实上，这确实可以缩短堆栈深度，尽管它并不普遍适用。

ps：我没有repl，所以有人可以测试修复trapoline fact 函数吗？

Answer 5

这是另一种方式：

(defn factorial [n]
  (reduce * (range 1 (inc n))))

这不会破坏堆栈，因为range 返回一个惰性序列，而reduce 在没有抓住头部的情况下穿过序列。

reduce 尽可能使用分块序列，因此这实际上比使用 recur 自己执行得更好。使用基于Siddhartha Reddy'srecur 的版本和基于reduce 的版本：

user> (time (do (factorial-recur 20000) nil))
"Elapsed time: 2905.910426 msecs"
nil
user> (time (do (factorial-reduce 20000) nil))
"Elapsed time: 2647.277182 msecs"
nil

只是略有不同。我喜欢将我的recurring 留给map 和reduce 和朋友们，它们更具可读性和明确性，并且在内部使用recur 比我可能手动操作要优雅一点。有时您需要手动 recur，但根据我的经验，这并不多。

Answer 6

堆栈深度是一个小麻烦（但可配置），但即使在具有尾递归的语言（如 Scheme 或 F#）中，您的代码最终也会耗尽堆栈空间。

据我所知，即使在透明支持尾递归的环境中，您的代码也不太可能进行尾递归优化。您可能希望查看延续传递样式以最小化堆栈深度。

这是来自 Wikipedia 的 Scheme 中的一个规范示例，可以毫不费力地翻译成 Clojure、F# 或其他函数式语言：

(define factorial
  (lambda (n)
      (let fact ([i n] [acc 1])
        (if (zero? i)
            acc
            (fact (- i 1) (* acc i))))))

Answer 7

按照 l0st3d 的建议，考虑使用 recur 或 lazy-seq。

另外，尝试通过使用内置序列形式构建序列来使序列变得惰性，而不是直接进行。

这是使用内置序列形式创建惰性斐波那契序列的示例（来自 Programming Clojure 书）：

(defn fibo []
  (map first (iterate (fn [[a b]] [b (+ a b)]) [0 1])))

=> (take 5 (fibo))
(0 1 1 2 3)

Answer 8

当我即将发布以下内容时，我发现它与 JasonTrue 发布的 Scheme 示例几乎相同......无论如何，这是 Clojure 中的一个实现：

user=> (defn fact[x]
        ((fn [n so_far]
          (if (<= n 1)
              so_far
              (recur (dec n) (* so_far n)))) x 1))
#'user/fact
user=> (fact 0)
1
user=> (fact 1)
1
user=> (fact 2)
2
user=> (fact 3)
6
user=> (fact 4)
24
user=> (fact 5)
120

等等

Answer 9

阶乘数本质上非常大。我不确定 Clojure 如何处理这个问题（但我确实看到它适用于 java），但任何不使用大数字的实现都会很快溢出。

编辑：这没有考虑到您为此使用递归这一事实，这也可能会耗尽资源。

Edit x2：如果实现使用大数字，据我所知，这通常是数组，再加上递归（每个函数条目一个大数字副本，由于函数调用总是保存在堆栈中）会解释堆栈溢出。尝试在 for 循环中执行此操作，看看是否是问题所在。