这个clojure素数序列有什么问题？

我不明白为什么惰性素数序列的定义会导致非终止。我得到的堆栈跟踪没有多大帮助。我对clojure的一个抱怨是堆栈跟踪迟钝

(declare naturals is-prime? primes)

(defn naturals
  ([] (naturals 1))
  ([n] (lazy-seq (cons n (naturals (inc n))))))

(defn is-prime? [n]
  (not-any? #(zero? (rem n %))
                (take-while #(> n (* % %)) (primes))))

(defn primes
  ([] (lazy-seq (cons 2 (primes 3))))
  ([n] (let [m (first (filter is-prime? (naturals n)))]
         (lazy-seq (cons m (primes (+ 2 m)))))))

(take 10 (primes)) ; this results in a stack overflow error

---

问题是，要知道如何计算素数函数，您使用的是素数？函数，然后计算出是素数？函数使用素数，因此堆栈溢出

所以要计算素数3，你需要计算第一个滤波器是素数？naturals 3，哪个叫做prime？1，它调用素数，它依次调用素数3。换句话说，你正在做：

user=> (declare a b)
#'user/b
user=> (defn a [] (b))
#'user/a
user=> (defn b [] (a))
#'user/b
user=> (a)
StackOverflowError   user/b (NO_SOURCE_FILE:1)

---

要了解如何生成素数：

问题是要知道如何计算使用的素数函数是素数？函数，然后计算出是素数？函数使用素数，因此堆栈溢出

所以要计算素数3，你需要计算第一个滤波器是素数？naturals 3，哪个叫做prime？1，它调用素数，它依次调用素数3。换句话说，你正在做：

user=> (declare a b)
#'user/b
user=> (defn a [] (b))
#'user/a
user=> (defn b [] (a))
#'user/b
user=> (a)
StackOverflowError   user/b (NO_SOURCE_FILE:1)

要了解如何生成素数：

让我们开始执行素数，我们将神奇地实现一个seq，只是为了弄清楚。我将忽略naturals，因为它确实是懒惰的：

 > (magically-realise-seq (primes))
=> (magically-realise-seq (lazy-seq (cons 2 (primes 3))))
=> (cons 2 (primes 3))
=> (cons 2 (let [m (first (filter is-prime? (naturals 3)))]
             (lazy-seq (cons m (primes (+ 2 3))))))
=> (cons 2 (let [m (first (filter
                            (fn [n]
                              (not-any? #(zero? (rem n %))
                                            (take-while #(> n (* % %)) (primes))))) 
                            (naturals 3)))]
             (lazy-seq (cons m (primes (+ 2 3))))))

我已经替换了素数？在最后的fn中，你可以看到素数将再次被调用，并且至少在take while拉出元素时实现一次。这将导致循环。

让我们开始执行素数，然后我们将神奇地实现一个序列，只是为了弄清楚。我将忽略naturals，因为它确实是懒惰的：

 > (magically-realise-seq (primes))
=> (magically-realise-seq (lazy-seq (cons 2 (primes 3))))
=> (cons 2 (primes 3))
=> (cons 2 (let [m (first (filter is-prime? (naturals 3)))]
             (lazy-seq (cons m (primes (+ 2 3))))))
=> (cons 2 (let [m (first (filter
                            (fn [n]
                              (not-any? #(zero? (rem n %))
                                            (take-while #(> n (* % %)) (primes))))) 
                            (naturals 3)))]
             (lazy-seq (cons m (primes (+ 2 3))))))

---

我已经替换了素数？在最后的fn中，你可以看到素数将再次被调用，并且至少在take while拉出元素时实现一次。这将导致循环。

我认为问题在于，您试图在构造素数之前使用素数

改变是最好的？这样就解决了问题：

(defn is-prime? [n]
     (not-any? #(zero? (rem n %))
               (take-while #(>= n (* % %)) (next (naturals)))))

---

注意，我已经用>=更改了>，否则它会给出4是素数。它仍然说1是prime，这是不正确的，如果使用is prime，可能会导致问题？其他地方。

我认为问题在于，在构造素数之前，您试图使用素数

改变是最好的？这样就解决了问题：

(defn is-prime? [n]
     (not-any? #(zero? (rem n %))
               (take-while #(>= n (* % %)) (next (naturals)))))

注意，我已经用>=更改了>，否则它会给出4是素数。它仍然说1是prime，这是不正确的，如果使用is prime，可能会导致问题？其他地方