Optional parameters are one of those things. Love them or hate them they have their place. Generally, F# style dictates using optional parameters over overloaded methods. From MSDN

In F#, optional arguments are usually used instead of overloaded methods. However, overloaded methods are permitted in the language

Briefly, the way to declare optional parameters in F# is as follows:

[sourcecode language="fsharp"]
type Person() =
///<summary>Pants are optional</summary>
member this.WearClothes(top, shoes, ?pants) = ignore()
[/sourcecode]

When we need to find the value of an optional we can use a function called defaultArg. It checks the call and if no value was passed, the value provided is used.

[sourcecode language="fsharp"]
type Person() =
member this.Say(message, ?name) =
let who = defaultArg name "nobody"
printfn "You said: '%s', to %s" message who
[/sourcecode]

When using polymorphism in F#, you declare the type signature, and optionally, a default implementation (equivalent to a virtual method in C#). If you intend to use optional parameters, in this case you'll need to use labels for optional parameters in your abstract declaration. You cannot use curried arguments either, so you must tuple your signature. Like so...

[sourcecode language="fsharp"]
type Person() =
abstract Say : 'a * ?name : string -> unit
default this.Say (message, ?name) =
(* and so on *)
[/sourcecode]

Aside: both optional parameters and parameter arrays must be used last in a method signature in F#. In the case you use both, the compiler fails unless the optional parameters go last. Those familiar with C# in this instance will know the opposite is true in that language. Odd?