The record type is a core feature in F#, but some of its details are not well-known. Let's delve into them.

Type Inference

Type inference in F# may sometimes deduce a record type differently than expected. For instance, in the following code, r is inferred as the B type, even though it match the A type, resulting in compiler errors:

type A = { X: int; Y: string }
type B = { Y: int; X: string }

let r = { X = 1; Y = "a" }

The compiler checks only the field names in the record type and selects the last record definition that matches.

To resolve these errors, we can use explicit type annotations:

let b: A = { X = 1; Y = "a" }

or

let b = { X = 1; Y = "a" } : A

Another option is to use the type in the field name:

let b = { A.X = 1; Y = "a" }

Pattern Matching

Pattern matching allows us to deconstruct records:

type User = { Name: string; Age: int }
let user = { Name = "John"; Age = 20 }
let { Name = name; Age = age } = user

We can deconstruct only specific fields and use other patterns inside, especially in combination with the as keyword:

type User = { Name: string; Age: int option; Email: string option; Address: string option }
let user = { Name = "John"; Age = None; Email = Some "someEmail"; Address = None }
match user with
| { Email = Some email } as u -> printfn "Sending email to %s: %s" u.Name email
| { Address = Some address } as u -> printfn "Sending a postcard to %s: %s" u.Name address
| u -> printfn "No contact info for %s" u.Name

This way, we can handle cases based on certain fields while still having access to the entire record.

Patterns can also be nested:

type Address = { Street: string; City: string }
type User = { Name: string; Age: int option; Email: string option; Address: Address option }

let { Address = { City = city } } = user

Default Values

Often, we need to create a record specifying only some fields and use default values for the rest. Although F# don't have direct support for this, it is common to use the Default static member:

type Config = {
    ServerAddress: string
    Port: int
    UseSSL: bool
    Timeout: System.TimeSpan option
} with
    static member Default = { ServerAddress = "localhost"; Port = 80; UseSSL = false; Timeout = None }

let config = { Config.Default with ServerAddress = "my-great-site.com" }

Updating Nested Records

Starting from F# 8, we can use shorthand syntax for updating nested records:

type PersonalInfo = { Age: int; Email: string }
type User = { Name: string; Info: PersonalInfo }

let user = { Name = "John"; Info = { Age = 20; Email = "john@email" }}
let user2 = { user with Info.Age = user.Info.Age + 1 }