如何使用高阶函数为素数计算定义筛函数？

Question

我在 Haskell 中有一个 sieve 的递归定义，用于计算素数。但我不知道如何使用 map 或 filter 等高阶函数编写相同的函数。谁能给我看看？

sieve [] = []
sieve (x:xs) = check (x:xs)

check [] = []
check (x:xs)
        |x/=2 && x/=3 && x/=5 && x/=7 = comp (x:xs)
        |otherwise    = x : sieve xs

comp [] = []
comp (x:xs)
        |x `mod` 2 == 0 = sieve xs
        |x `mod` 3 == 0 = sieve xs
        |x `mod` 5 == 0 = sieve xs
        |x `mod` 7 == 0 = sieve xs
        |otherwise      = x : sieve xs

Answer 1

使用map 和filter 和iterate；很慢：

primes = map head $ iterate (\(x:xs) -> filter ((> 0).(`rem`x)) xs) [2..]

加上concat； 速度快得多，复杂性也大大提高：

primes = concat . map fst $ 
   iterate (\(_, (p:ps, xs)) -> case span (< p*p) xs of
                   { (h,t) -> (h, (ps, filter ((> 0).(`rem`p)) t)) }) 
           ([2], (primes, [3..]))

更多信息请访问Haskell wiki。

---

如果您愿意，可以通过map 表达iterate：

iterate f x = let { r = x : map f r } in r

还有filter：

filter f xs = concat $ map (\x -> [x | f x]) xs

---

但是对于 Eratosthenes 的 true 筛子，它不通过可分性测试检测复合物，而是直接从它找到的素数生成它们，并在由此生成的复合物之间的间隙中找到素数，-我们需要更多辅助功能，如minus and union 和treelike-folding foldi（foldr 可以用来代替foldi，但速度会降低，复杂性会变差）：

primes = 2 : _Y ((3:) . minus [5,7..]     
                         . foldi (\(x:xs) ys -> x : union xs ys) [] 
                            . map (\p -> [p*p, p*p+2*p..]))
_Y g = g (_Y g) 

这运行得更快，接近使用 Haskell 的不可变代码可实现的最佳 empirical orders of growth。不可变数组可以更快，但这里将它们排除在外，因为 a。这不是问题，b。它们的性能取决于给定的 Haskell 实现，而不是用户代码。可变数组当然是最快的，但代码更复杂。

Answer 2

我很快把这个拼凑起来，速度不是很好，但是很容易实现。

primes'::[Int]->[Int]
primes' [] = []
primes' (x:xs) = x:primes (filter ((/= 0) . (`mod` x)) xs)

main = print $ primes [2..20] -- always input a contiguous list from 2 to N.