F# – Record types vs classes

In F#, you can defined record types which differ from tuples and discriminated unions in that they allow you to organize values into a type and name those values through fields:

Looks like a cut-down version of a standard .Net class with a couple of properties? Yes they do, but records offer several advantages over the .Net classes.

Type Inference

One of the biggest advantage records offer is that it works seamlessly with F#’s type inference system. Whereas classes must be annotated in order to be used, record types can be inferred by the fields you access!

Consider this simple function:

and see what its function signature reads:

Magic! Well, with a caveat :-P As you can imagine, if you define a second record type which contains the same set of fields then it might just confuses the compiler a little. For instance, if you define a record type for employees:

The function signature for the printPerson function will become:

So to tell the printPerson function to use the Person record instead, you’ll need to annotate the parameter p:

Immutability

Unlike classes, record fields are immutable by default. This immutability by default approach (zero side effect) is inline with everything else in F# and in functional languages in general, and offers a degree of safety guarantee.

However, whether immutability is an advantage very much depends on your use case, Eric Lippert made an excellent argument here that the lack of side effects and immutable data structures function languages offer are both advantages and disadvantages.

Fortunately, with F# record types, it’s possible to change the field values, either by using the copy and update record expression:

or you can explicitly specify that a field should be mutable:

then you are allowed to update the value of the mutable fields:

No Inheritance

Records cannot be inherited, which gives you a future guarantee of safety but then again you can equally make arguments against it, another post another day maybe..

Pattern Matching

Records can be used as part of standard pattern matching whereas classes cannot without resorting to active patterns or with when guards.

This is important, as you’re likely to be using pattern matching everywhere in your code and frankly, why wouldn’t you? It’s so awesome ;-) You can mach the structure of records and not every record field needs to be a part of the pattern match:

Equally you can capture values and match literal:

Structural Equality Semantics

Standard .Net classes have reference equality semantics (two reference type variables are deemed equal if they point to the same location in memory), but records have structural equality semantics (two values are deemed equal if their fields are equal):

In this respect, records are the same as .Net structs, which also structural equality semantics and cannot be inherited.

Update 27/09/2011:

One thing I forgot to mention is that whilst you can define a record type with just the list of fields, you can also add methods and properties using the member keyword: