Record-type recursive member functions and the “rec” keyword

Question

I've always believed that in F# we needed to use the rec keyword for every recursive function, for example:

let rec factorial = function
| 0 -> 1
| k when k > 0 ->  k * (factorial (k - 1))
| failwith "oops!"

Today I was playing around with F# and I came up with a code similar to the following:

let MyRecordType =
    { Something     : float;
      SomethingElse : int }
    with
        static member factorial = function
            | 0 -> 1
            | k when k > 0 ->  k * (MyRecordType.factorial (k - 1))
            | failwith "oops!"

As you see, I've just defined a recursive function, but I made what at first seemed like a mistake: I forgot to declare the function as recursive by means of the rec keyword.

But to my surprise it compiles! And there's more to it: if you add the rec keyword, then it is a syntax error!

type MyRecordType =
    { (* ... *) }
    with
        // syntax error:
        static member rec factorial = function
        (* ... *)

I've googled around for an explanation but got nothing. In the MSDN documentation, I couldn't find any mention to the rec keyword outside the page about recursive functions, and as of 2010-01-03 it does not mention the case I'm asking about.

Exactly the same thing happens with non-static members.

So, why is it a syntax error to use the rec keyword on member functions of a record-type?

Answer 1

'let rec' isn't about defining recursive functions, but defining a binding in an environment, that includes the binding for the current variable to be bound. You could use 'let rec' just as well to define e.g. an infinite list. Often, you don't want the binding to be included in the environment, as you might want to access an earlier variable by the same name.

When you are defining the static member function, factorial, you aren't looking for a binding for a variable 'factorial', but for a type 'MyRecordType' (which is in the environment as a type definition), and if it happens to have a static member function called 'factorial', which it has.

Answer 2

All "member" functions are implicitly "rec" within the type they're defined in.