Haskell如何评估该素数函数？

Question

I find it rather difficult to understand how Haskell will evaluate this primes function. Is the primes function get evaluated over and over, or the primes in the primeFactors function will point back to the first primes ?

primes = 2 : filter ((==1) . length . primeFactors) [3,5..]

primeFactors n = factor n primes
  where
    factor n (p:ps)
        | p * p > n        = [n]
        | n `mod` p == 0   = p : factor (n `div` p) (p:ps)
        | otherwise        = factor n ps

main :: IO ()
main = print $ length . take 100000 $ primes

Answer 1

primes is just a list. Its first element is 2, and the rest of the elements are taken from the list of odd integers filtered by (in part) the function primeFactors .

primeFactors , though, uses primes . Isn't this circular?

Not quite. Because Haskell is lazy, primeFactors doesn't need all the values in primes at once, just the ones that are less than or equal to the square root of its argument ( p:ps matches against primes , but we only need ps if p*p <= n ), and those primes were all found by previous calls to primeFactors .

As an example, trace the first few calls to primeFactors . For brevity, let b = (==1) . length . primeFactors b = (==1) . length . primeFactors b = (==1) . length . primeFactors .

primeFactors 3 == factor 3 primes
               -- only unpack as much of primes as we need for the next step
               == factor 3 (2:filter b [3,5..])
               -- because 2*2 > 3, that's only one level
               == [3]

And so, since b [3] is true, we know that 3 is the next element of primes . That is, primes = 2:3:filter b [5,7..]

primeFactors 5 == factor 5 primes
               == factor 5 (2:3:filter b [3,5..])
               -- 2*2 > 5 is false, as is 5 `mod` 2 == 0, so
               == factor 5 (3:filter b [3,5..])
               -- 3*3 > 5, so
               == [5]

And b [5] is true, so 5 is the next element of primes .

primeFactors 7 == factor 7 primes
               == factor 7 (2:3:5:filter b [3,5..])
               == factor 7 (3:5:filter b [3,5..])
               -- 3*3 > 7
               == [7]

And b [7] is true, so 7 is the next element of primes . (Seems like everything gets added to primes , doesn't? One more call to primeFactors will show that isn't the case)

primeFactors 9 == factor 9 primes
               == factor 9 (2:3:5:7:filter b [3,5..])
               -- 2*2 > 9 and 9 `mod` 2 == 0 are false
               == factor 9 (3:5:7:filter b [3,5..])
               -- 3*3 > 9 is false, but 9 `mod` 3 == 0 is true, so
               == 3 : factor (9 `div` 3) (3:5:7:filter b [3,5..])
               == 3 : factor 3 (3:5:7:filter b [3,5..])
               -- 3*3 > 3 is false, but 3 `mod` 3 == 0, so
               == 3 : [3] == [3,3]

But since b [3,3] is false, 9 is not an element of primes . So now we have

 primes = 2:3:5:7:filter b [3,5..])

It's a long and tedious process to trace this, but you should get the feeling that primes always stays "ahead" of primeFactors ; the elements of primes that primeFactors needs have always been determined by earlier calls to primeFactors .

Answer 2

how Haskell will evaluate this primes function?

As your code shown in question, it print out first 100000 prime numbers, so how primes to work?

Firstly, for generating the first prime number, it is simple, just first element of the list:

2 : filter ((==1) ...

that is 2 , and for the next one, we need to apply primeFactors function as

primeFactors 3 = factor 3 primes

and now may confuse someone who new to Haskell, how to evaluate the primes in above expression? the answer is that, it is just a list with elements as [2,...] , thanks to lazy evaluation, now, we don't need to evaluate all the prime numbers of list generated by primes function. we just need to evaluate next one and look and see what happen. So, we get 2 , and the above expression become:

 primeFactors 3 = factor 3 [2,..]

and

factor 3 (2:ps) | 2 * 2 > 3 = [3]

So, primeFactors 3 retrun [3]

and, so

2: filter ((==1) . length . primeFactors) 3 = [2,3]

we now successfully generate 2 prime numbers, but we need 100000, and how about next? Obviously, we apply 5 to below expression:

2: filter ((==1) . length . primeFactors) 5

repeats the procedure as above:

primeFactors 5 = factor 5 [2,3,..]

and this time we have 2 elements in the list:

factor 5 [2,3..]

and

factor 5 [2,3..] | otherwise = factor 5 [3,...]

and

factor 5 [3,...] | 3 * 3 > 5 = [5]

and repeat again and again till to generate 100000 prime numbers, and again, due to lazy evaluation, we don't need 100001 prime number, so the computation stop and print out the result.