Python Clojure素数惰性序列

以下Python代码的Clojure等价物（精确算法）是什么

from itertools import count
from math import sqrt

def prime_gen():
   primes = []
   for n in count(2):
       if all(n%p for p in primes if p <= sqrt(n)):
           primes.append(n)
           yield n

来自itertools导入计数
从数学导入sqrt
def prime_gen（）：
素数=[]
对于计数中的n（2）：
如果所有（n%p表示素数中的p，如果p，这是我所能做的Pythonish：

(def prime-gen
     (let [primes (atom [])]
       (for [n (iterate inc 2)
             :when (not-any? #(zero? (rem n %))
                             (filter #(<= % (Math/sqrt n)) 
                                     @primes))]
         (do (swap! primes conj n)
             n))))

(take 10 prime-gen)  ; => (2 3 5 7 11 13 17 19 23 29)

（def主发电机
（让[素数（原子[]）]
（对于[n（迭代inc 2）
：何时（不是任何？#（零？（rem n%））
（过滤器#）（2 3 5 7 11 13 17 19 23 29）

 Culjule不认为整数0是布尔错误。我花了几分钟才知道您的Python代码利用了这个。
Clojure中还有一些其他素数算法。Clojure.contrib.lazy seqs中也有一个素数实现

这个版本比@Brian Carper的要快得多

(def prime-gen
  (let [primes (atom [2N])]
    (iterate
      #(let [ps @primes]
         (loop [n (inc %)]
           (if (loop [i 0]
                 (let [p (nth ps i)]
                   (cond
                     (< n (* p p)) true
                     (zero? (mod n p)) false
                     :else (recur (inc i)))))
             (do (swap! primes conj n) n)
             (recur (inc n)))))
      (first @primes))))

（def主发电机
（设[素数（原子[2N]）]
（迭代
#（让[ps@primes]
（循环[n（inc%）]
（如果（循环[i 0]
（让[p（n次ps i）]
（续）
（

这是非常惯用的Clojure中的算法。我试图保持名称不变，以便您可以看到此代码的对应关系

（定义全部？（部分每个？标识））
（defn prime gen[]
（展开
（迭代
（fn步骤[[素数n]]
(若)(全部)？
（对于[p primes:when（不需要是可怜的：）如果有一个更惯用的clojure解决方案用于同一个算法，请也发送它。你应该遵循链接。那里有很多例子和答案。还有。好吧，除了变异一个
原子
，它并不是完全不成文法的。但是要避免使用
原子
，需要一些扭曲。有些算法需要边effects和非函数式编程风格（特别是像就地排序、洗牌、特定数学函数等）在这些情况下，切换到使用可变数据结构是可以的。这就是Clojure提供这些数据结构的原因。您甚至可以深入研究并使用本机Java数据结构来处理这类事情。仅供参考，Python中的精确算法很弱。请查找Alex Martelli高效的无限素数生成器。
(take 11 (prime-gen))
=> (2 3 5 7 11 13 17 19 23 29 31)