Question

I write some code to learning F#.
Here is a example:

let nextPrime list=
    let rec loop n=
        match n with
        | _ when (list |> List.filter (fun x -> x <= ( n |> double |> sqrt |> int)) |> List.forall (fun x -> n % x <> 0)) -> n
        | _ -> loop (n+1)
    loop (List.max list + 1)

let rec findPrimes num=
    match num with
    | 1 -> [2]
    | n -> 
        let temp = findPrimes <| n-1
        (nextPrime temp ) :: temp

//find 10 primes
findPrimes 10 |> printfn "%A"

I’m very happy that it just works!

I’m totally beginner to recursion

Recursion is a wonderful thing.

I think findPrimes is not efficient.

Someone help me to refactor findPrimes to tail recursion if possible?

BTW, is there some more efficient way to find first n primes?

Answer 1

Regarding the first part of your question, if you want to write a recursive list building function tail-recursively you should pass the list of intermediate results as an extra parameter to the function. In your case this would be something like

let findPrimesTailRecursive num =
    let rec aux acc num = 
        match num with
        | 1 -> acc
        | n -> aux ((nextPrime acc)::acc) (n-1)
    aux [2] num

The recursive function aux gathers its results in an extra parameter conveniently called acc (as in acc-umulator). When you reach your ending condition, just spit out the accumulated result. I’ve wrapped the tail-recursive helper function in another function, so the function signature remains the same.

As you can see, the call to aux is the only, and therefore last, call to happen in the n <> 1 case. It’s now tail-recursive and will compile into a while loop.

I’ve timed your version and mine, generating 2000 primes. My version is 16% faster, but still rather slow. For generating primes, I like to use an imperative array sieve. Not very functional, but very (very) fast.