Like methods, properties can take arguments; these are called indexer properties. The most commonly defined indexer property is called Item, and the Item property on a value v is accessed via the special notation v.[i]. As the notation suggests, these properties are normally used to implement the lookup operation on collection types. The following example implements a sparse vector in terms of an underlying sorted dictionary:

open System.Collections.Generic
type SparseVector(items: seq<int * float>)=
    let elems = new SortedDictionary<_,_>()
    do items |> Seq.iter (fun (k,v) -> elems.Add(k,v))

    /// This defines an indexer property
    member t.Item
        with get(idx) =
            if elems.ContainsKey(idx) then elems.[idx]
            else 0.0

You can define and use the indexer property as follows:

> let v = SparseVector [(3,547.0)];;
val v : SparseVector

> v.[4];;
val it : float = 0.0

> v.[3];;
val it : float = 547.0

You can also use indexer properties as mutable setter properties with the syntax expr.[expr] <- expr. This is covered in the section "Defining Object Types with Mutable State." Indexer properties can also take multiple arguments; for example, the indexer property for the F# Power Pack type Microsoft.FSharp.Math.Matrix<'T> takes two arguments. Chapter 10 describes this type.

Types can also include the definition of overloaded operators. Typically, you do this by defining static members with the same names as the relevant operators. Here is an example:

type Vector2DWithOperators(dx:float,dy:float) =
    member x.DX = dx

member x.DY = dy

    static member (+) (v1: Vector2DWithOperators ,v2: Vector2DWithOperators) =
        Vector2DWithOperators(v1.DX + v2.DX, v1.DY + v2.DY)

    static member (-) (v1: Vector2DWithOperators ,v2: Vector2DWithOperators) =
        Vector2DWithOperators (v1.DX - v2.DX, v1.DY - v2.DY)

> let v1 = new Vector2DWithOperators (3.0,4.0);;
val v1 : Vector2DWithOperators

> v1 + v1;;
val it : Vector2DWithOperators = { DX=6.0; DY=8.0 }

> v1 - v1;;
val it : Vector2DWithOperators = { DX=0.0; DY=0.0 }

If you add overloaded operators to your type, you may also have to customize how generic equality, hashing, and comparison are performed. In particular, the behavior of generic operators such as hash, <, >, <=, >=, compare, min, and max isn't specified by defining new static members with these names, but rather by the techniques described in Chapter 8.

let inline (+) x y = ((^a or ^b): (static member (+) : ^a * ^b -> ^c) (x,y))

let (++) x y = List.append x [y]

The F# OO constructs are designed largely for use in APIs for software components. Two useful mechanisms in APIs permit callers to name arguments and let API designers make certain arguments optional.

Named arguments are simple. For example, in Listing 6-2, the implementations of some methods specify arguments by name, as in the expression Vector2D(dx=dx+x, dy=dy). You can use named arguments with all dot-notation method calls. Code written using named arguments is often much more readable and maintainable than code relying on argument position. The rest of this book frequently uses named arguments.

You declare a member argument optional by prefixing the argument name with ?. Within a function implementation, an optional argument always has an option<_> type; for example, an optional argument of type int appears as a value of type option<int> within the function body. The value is None if no argument is supplied by the caller and Some(arg) if the argument arg is given by the caller. For example:

open System.Drawing

type LabelInfo(?text:string, ?font:Font) =
    let text = defaultArg text ""
    let font = match font with
               | None -> new Font(FontFamily.GenericSansSerif,12.0f)
               | Some v -> v
    member x.Text = text
    member x.Font = font

The inferred signature for this type shows how the optional arguments have become named arguments accepting option values:

type LabelInfo =
    new : text:string option * font:System.Drawing.Font option -> LabelInfo
    member Font : System.Drawing.Font
    member Text : string

You can now create LabelInfo values using several different techniques:

> LabelInfo (text="Hello World");;
val it : LabelInfo =
    {Font = [Font: Name=Microsoft Sans Serif, Size=12]; Text = "Hello World"}

> LabelInfo("Goodbye Lenin");;
val it : LabelInfo =
    {Font = [Font: Name=Microsoft Sans Serif, Size=12];  Text = "Goodbye Lenin"}

> LabelInfo(font=new Font(FontFamily.GenericMonospace,36.0f),
            text="Imagine");;
val it : LabelInfo =
   {Font = [Font: Name=Courier New, Size=36]; Text = "Imagine"}

Optional arguments must always appear last in the set of arguments accepted by a method. They're usually used as named arguments by callers.

The implementation of LabelInfo uses the F# library function defaultArg, which is a useful way to specify simple default values for optional arguments. Its type is as follows:

val defaultArg : 'T option -> 'T-> 'T

Throughout this book, you've used a second technique to specify configuration parameters when creating objects: initial property settings for objects. For example, in Chapter 2, you used the following code:

open System.Windows.Forms
let form = new Form(Visible=true,TopMost=true,Text="Welcome to F#")

The constructor for the System.Windows.Forms.Form class takes no arguments, so in this case the named arguments indicate post-hoc set operations for the given properties. The code is shorthand for this:

open System.Windows.Forms

let form =
    let tmp = new Form()
    tmp.Visible <- true
    tmp.TopMost <- true
    tmp.Text <- "Welcome to F#"
    tmp

The F# compiler interprets unused named arguments as calls that set properties of the returned object. This technique is widely used for mutable objects that evolve over time, such as graphical components, because it greatly reduces the number of optional arguments that need to be plumbed around. Here's how to define a version of the LabelInfo type used earlier that is configurable by optional property settings:

open System.Drawing

type LabelInfoWithPropertySetting() =
    let mutable text = "" // the default
    let mutable font = new Font(FontFamily.GenericSansSerif,12.0f)
    member x.Text with get() = text and set v = text <- v
    member x.Font with get() = font and set v = font <- v

> LabelInfoWithPropertySetting(Text="Hello World");;
val it : LabelInfo =
    {Font = [Font: Name=Microsoft Sans Serif, Size=12]; Text = "Hello World"}

You use this technique in Chapter 11 when you learn how to define a Windows Forms control with configurable properties. The "Defining Object Types with Mutable State" section later in this chapter covers mutable objects in more detail.

.NET APIs and other OO design frameworks frequently use a notational device called method overloading. This means a type can support multiple methods with the same name, and uses of methods are distinguished by name, number of arguments, and argument types. For example, the System.Console.WriteLine method of .NET has 19 overloads!

Method overloading is used relatively rarely in F#-authored classes, partly because optional arguments and mutable property setters tend to make it less necessary. However, method overloading is permitted in F#. First, methods can easily be overloaded by the number of arguments. For example, Listing 6-3 shows a concrete type representing an interval of numbers on the number line. It includes two methods called Span, one taking a pair of intervals and the other taking an arbitrary collection of intervals. The overloading is resolved according to argument count.

/// Interval(lo,hi) represents the range of numbers from lo to hi,
/// but not including either lo or hi.
type Interval(lo,hi) =
    member r.Lo = lo
    member r.Hi = hi
    member r.IsEmpty = hi <= lo
    member r.Contains v = lo < v && v < hi

    static member Empty = Interval(0.0,0.0)

    /// Return the smallest interval that covers both the intervals
    /// This method is overloaded.
    static member Span (r1:Interval, r2:Interval) =
        if r1.IsEmpty then r2 else
        if r2.IsEmpty then r1 else
        Interval(min r1.Lo r2.Lo, max r1.Hi r2.Hi)

    /// Return the smallest interval that covers all the intervals
    /// This method is overloaded.
    static member Span(ranges: seq<Interval>) =
        Seq.fold (fun r1 r2 -> Interval.Span(r1,r2)) Interval.Empty ranges

Second, multiple methods can also have the same number of arguments and be overloaded by type. One of the most common examples is providing multiple implementations of overloaded operators on the same type. The following example shows a Point type that supports two subtraction operations, one subtracting a Point from a Point to give a Vector and one subtracting a Vector from a Point to give a Point:

type Vector =
    { DX:float; DY:float }
    member v.Length = sqrt(v.DX*v.DX+v.DY*v.DY)

type Point =
    { X:float; Y:float }

    static member (-) (p1:Point,p2:Point) = { DX=p1.X-p2.X; DY=p1.Y-p2.Y }

    static member (-) (p:Point,v:Vector) = { X=p.X-v.DX; Y=p.Y-v.DY }

Overloads must be unique by signature, and you should take care to make sure your overload set isn't too ambiguous—the more overloads you use, the more type annotations users of your types will need to add.

The key definition in Listing 6-5 is the following (it also uses Rectangle and Point, two types from the System.Drawing namespace):

open System.Drawing
type IShape =
    abstract Contains : Point -> bool
    abstract BoundingBox : Rectangle

Here you use the keyword abstract to define the member signatures for this type, indicating that the implementation of the member may vary from value to value. Also note that IShape isn't concrete; it's neither a record nor a discriminated union or class type. It doesn't have any constructors and doesn't accept any arguments. This is how F# infers that it's an object interface type.

The following code from Listing 6-5 implements the object interface type IShape using an object expression:

let circle(center:Point,radius:int) =
    { new IShape with
          member x.Contains(p:Point) =
              let dx = float32 (p.X - center.X)
              let dy = float32 (p.Y - center.Y)
              sqrt(dx*dx+dy*dy) <= float32 radius
          member x.BoundingBox =
              Rectangle(center.X-radius,center.Y-radius,2*radius+1,2*radius+1) }

The type of the function circle is as follows:

val circle : Point * int -> IShape

The construct in the braces, { new IShape with ... }, is the object expression. This is a new expression form that you haven't encountered previously in this book, because it's generally used only when implementing object interface types. An object expression must give implementations for all the members of an object interface type. The general form of this kind of expression is simple:

{ new Type optional-arguments with
       member-definitions
  optional-extra-interface-definitions }

The member definitions take the same form as members for type definitions described earlier in this chapter. The optional arguments are given only when object expressions inherit from a class type, and the optional interface definitions are used when implementing additional interfaces that are part of a hierarchy of object interface types.

You can use the function circle as follows:

> let bigCircle = circle(Point(0,0), 100);;
val bigCircle : IShape

> bigCircle.BoundingBox;;
val it : Rectangle = {X=-100,Y=-100,Width=201,Height=201}

> bigCircle.Contains(Point(70,70));;
val it : bool = true

> bigCircle.Contains(Point(71,71));;
val it : bool = false

Listing 6-5 also contains another function square that gives a different implementation for IShape, also using an object expression:

> let smallSquare = square(Point(1,1), 1);;
val smallSquare : IShape

> smallSquare.BoundingBox;;
val it : Rectangle = {X=0,Y=0,Width=2,Height=2}

> smallSquare.Contains(Point(0,0));;
val it : bool = false

It's common to have concrete types that both implement one or more object interface types and provide additional services of their own. Collections are a primary example, because they always implement IEnumerable<'T>. To give another example, in Listing 6-5 the type MutableCircle is defined as follows:

type MutableCircle() =
    let mutable center = Point(x=0,y=0)
    let mutable radius = 10
    member c.Center with get() = center and set v = center <- v
    member c.Radius with get() = radius and set v = radius <- v
    member c.Perimeter = 2.0 * System.Math.PI * float radius
    interface IShape with
        member c.Contains(p:Point) =
            let dx = float32 (p.X - center.X)
            let dy = float32 (p.Y - center.Y)
            sqrt(dx*dx+dy*dy) <= float32 radius
        member c.BoundingBox =
            Rectangle(center.X-radius,center.Y-radius,2*radius+1,2*radius+1)

This type implements the IShape interface, which means MutableCircle is a subtype of IShape, but it also provides three properties—Center, Radius, and Perimeter—that are specific to the MutableCircle type, two of which are settable. The type has the following signature:

type MutableCircle =
    interface IShape
    new : unit -> MutableCircle
    member Perimeter : float
    member Center : Point with get,set
    member Radius : int with get,set

You can now reveal the interface (through a type cast) and use its members. For example:

> let circle2 = MutableCircle();;
val circle2 : MutableCircle

> circle2.Radius;;
val it : int = 10

> (circle2 :> IShape).BoundingBox;;
val it : Rectangle = {X=-10,Y=-10,Width=21,Height=21}

Like other constructs discussed in this chapter, object interface types are often encountered when using .NET libraries. Some object interface types such as IEnumerable<'T> (called seq<'T> in F# coding) are also used throughout F# programming. It's a .NET convention to prefix the name of all object interface types with I. However, using object interface types is very common in F# OO programming, so this convention isn't always followed.

Here's the essence of the definition of the System.Collections.Generic.IEnumerable<'T> type and the related type IEnumerator using F# notation:

type IEnumerator<'T> =
    abstract Current : 'T
    abstract MoveNext : unit -> bool

type IEnumerable<'T> =
    abstract GetEnumerator : unit -> IEnumerator<'T>

The IEnumerable<'T> type is implemented by most concrete collection types. It can also be implemented by a sequence expression or by calling a library function such as Seq.unfold, which in turn uses an object expression as part of its implementation.

Some other useful predefined F# and .NET object interface types are as follows:

Object interface types can be arranged in hierarchies using interface inheritance. This provides a way to classify types. To create a hierarchy, you use the inherit keyword in an object interface type definition along with each parent object interface type. For example, the .NET Framework includes a hierarchical classification of collection types: ICollection<'T> extends IEnumerable<'T>. Here are the essential definitions of these types in F# syntax, with some minor details omitted:

type IEnumerable<'T> =
    abstract GetEnumerator : unit -> IEnumerator<'T>

type ICollection<'T> =
    inherit IEnumerable<'T>
    abstract Count : int
    abstract IsReadOnly : bool
    abstract Add : 'T -> unit
    abstract Clear : unit -> unit
    abstract Contains  : 'T -> bool
    abstract CopyTo  : 'T[] * int -> unit
    abstract Remove  : 'T -> unit

When you implement an interface that inherits from another interface, you must effectively implement both interfaces.

One of the easiest ways to build a partial implementation of an object is to qualify the implementation of the object by a number of function parameters that complete the implementation. For example, the following code defines an object interface type called ITextOutputSink, a partial implementation of that type called simpleOutputSink, and a function called simpleOutputSink that acts as a partial implementation of that type. The remainder of the implementation is provided by a function parameter called writeCharFunction:

/// An object interface type that consumes characters and strings
type ITextOutputSink =

    /// When implemented, writes one Unicode character to the sink
    abstract WriteChar : char -> unit

    /// When implemented, writes one Unicode string to the sink
    abstract WriteString : string -> unit

/// Returns an object that implements ITextOutputSink by using writeCharFunction
let simpleOutputSink writeCharFunction =
    { new ITextOutputSink with
          member x.WriteChar(c) = writeCharFunction c
          member x.WriteString(s) = s |> String.iter x.WriteChar }

This construction function uses function values to build an object of a given shape. Here the inferred type is as follows:

val simpleOutputSink: (char -> unit) -> ITextOutputSink

The following code instantiates the function parameter to output the characters to a particular System.Text.StringBuilder object, an imperative type for accumulating characters in a buffer before converting these to an immutable System.String value:

let stringBuilderOuputSink (buf : System.Text.StringBuilder ) =
    simpleOutputSink (fun c -> buf.Append(c) |> ignore)

Here is an example that uses this function interactively:

> let buf = new System.Text.StringBuilder();;
val buf : StringBuilder

> let c = stringBuilderOuputSink(buf);;
val c : ITextOutputSink

> ["Incy"; " "; "Wincy"; " "; "Spider"] |> List.iter c.WriteString;;
val it : unit = ()

> buf.ToString();;
val it : string = "Incy Wincy Spider"

Object expressions must give definitions for all unimplemented abstract members and can't add other members.

One powerful technique implements some or all abstract members in terms of function parameters. As you saw in Chapter 3, function parameters can represent a wide range of concepts. For example, here is a type CountingOutputSink that performs the same role as the earlier function simpleOutputSink, except that the number of characters written to the sink is recorded and published as a property:

/// A type which fully implements the ITextOutputSink object interface
type CountingOutputSink(writeCharFunction: char -> unit) =

    let mutable count = 0

    interface ITextOutputSink with
        member x.WriteChar(c) = count <- count + 1; writeCharFunction(c)
        member x.WriteString(s) = s |> String.iter (x :> ITextOutputSink).WriteChar

    member x.Count = count

In this chapter, you've seen how to define concrete types, such as Vector2D in Listings 6-2 and 6-3, and you've seen how to define object interface types, such as IShape in Listing 6-5. Sometimes it's useful to define types that are halfway between these types: partially concrete types. Partially implemented types are class types that also have abstract members, some of which may be unimplemented and some of which may have default implementations. For example, consider the following class:

/// A type whose members are partially implemented
[<AbstractClass>]
type TextOutputSink() =
    abstract WriteChar : char -> unit
    abstract WriteString : string -> unit
    default x.WriteString s = s |> String.iter x.WriteChar

This class defines two abstract members, WriteChar and WriteString, but gives a default implementation for WriteString in terms of WriteChar. Because WriteChar isn't yet implemented, you can't create an instance of this type directly; unlike other concrete types, partially implemented types still need to be implemented. One way to do this is to complete the implementation via an object expression. For example:

{ new TextOutputSink() with
      member x.WriteChar c = System.Console.Write(c) }

This section covers how you can use partially implemented types to build complete objects. One approach is to instantiate one or more partially implemented types to put together a complete concrete type. This is often done via delegation to an instantiation of the partially concrete type; for example, the following example creates a private, internal TextOutputSink object whose implementation of WriteChar counts the number of characters written through that object. You use this object to build the HtmlWriter object that publishes three methods specific to the process of writing a particular format:

/// A type which uses a TextOutputSink internally
type HtmlWriter() =
    let mutable count = 0
    let sink =
        { new TextOutputSink() with
              member x.WriteChar c =
                  count <- count + 1;
                  System.Console.Write c }

    member x.CharCount = count
    member x.WriteHeader() = sink.WriteString("<html>")
    member x.WriteFooter() = sink.WriteString("</html>")
    member x.WriteString(s) = sink.WriteString(s)

Another technique to use partially implemented types is called implementation inheritance, which is widely used in OO languages despite being a somewhat awkward technique. Implementation inheritance tends to be much less significant in F# because it comes with major drawbacks:

If implementation inheritance is used, you should in many cases consider making all implementing classes private or hiding all implementing classes behind a signature. For example, the Microsoft.FSharp.Collections.Seq module provides many implementations of the seq<'T> interface but exposes no implementation inheritance.

Nevertheless, hierarchies of classes are important in domains such as GUI programming, and the technique is used heavily by .NET libraries written in other .NET languages. For example, System.Windows.Forms.Control, System.Windows.Forms.UserControl, and System.Windows.Forms.RichTextBox are part of a hierarchy of visual GUI elements. Should you want to write new controls, then you must understand this implementation hierarchy and how to extend it. Chapter 11 shows a complete example of extending UserControl. However, even in this domain, implementation inheritance is often less important than you may think, because these controls can often be configured in powerful and interesting ways by adding function callbacks to events associated with the controls.

Here is a simple example of applying the technique to instantiate and extend the partially implemented type TextOutputSink:

/// An implementation of TextOutputSink, counting the number of bytes written
type CountingOutputSinkByInheritance() =
    inherit TextOutputSink()

    let mutable count = 0

    member sink.Count = count

    default sink.WriteChar c =
        count <- count + 1;
        System.Console.Write c

The keywords override and default can be used interchangeably; both indicate that an implementation is being given for an abstract member. By convention, override is used when giving implementations for abstract members in inherited types that already have implementations, and default is used for implementations of abstract members that didn't previously have implementations.

Implementations are also free to override and modify default implementations such as the implementation of WriteString provided by TextOutputSink. Here is an example:

{ new TextOutputSink() with
      member sink.WriteChar c = System.Console.Write c
      member sink.WriteString s = System.Console.Write s }

You can also build new partially implemented types by extending existing partially implemented types. The following example takes the TextOutputSink type from the previous section and adds two abstract members called WriteByte and WriteBytes, adds a default implementation for WriteBytes, adds an initial implementation for WriteChar, and overrides the implementation of WriteString to use WriteBytes. The implementations of WriteChar and WriteString use the .NET functionality to convert the Unicode characters and strings to bytes under System.Text.UTF8Encoding, documented in the .NET Framework class libraries:

open System.Text

/// A component to write bytes to an output sink
[<AbstractClass>]
type ByteOutputSink() =
    inherit TextOutputSink()

    /// When implemented, writes one byte to the sink
    abstract WriteByte : byte -> unit

    /// When implemented, writes multiple bytes to the sink
    abstract WriteBytes : byte[] -> unit

    default sink.WriteChar c = sink.WriteBytes(Encoding.UTF8.GetBytes [|c|])

    override sink.WriteString s = sink.WriteBytes(Encoding.UTF8.GetBytes s)

    default sink.WriteBytes b = b |> Array.iter sink.WriteByte

It's occasionally useful to direct the F# compiler to use a .NET struct (value type) representation for small, generally immutable objects. You can do this by adding a Struct attribute to a class type and adding type annotations to all arguments of the primary constructor:

[<Struct>]
type Vector2DStruct(dx : float, dy: float) =
    member v.DX = dx
    member v.DY = dy
    member v.Length = sqrt (dx * dx + dy * dy)

Finally, you can also use a form that makes the values held in a struct explicit:

[<Struct>]
type Vector2DStructUsingExplicitVals =
    val dx : float
    val dy: float
    member v.DX = v.dx
    member v.DY = v.dy
    member v.Length = sqrt (v.dx * v.dx + v.dy * v.dy)

Structs are often more efficient, but you should use them with care because the full contents of struct values are frequently copied. The performance characteristics of structs can also change depending on whether you're running on a 32-bit or 64-bit machine.

Occasionally, you need to define a new .NET delegate type in F#:

type ControlEventHandler = delegate of int -> bool

This is usually required only when using C code from F#, because some magic performed by the .NET Common Language Runtime lets you marshal a delegate value as a C function pointer. Chapter 17 looks at interoperating with C and COM. For example, here's how you add a new handler to the Win32 Ctrl+C–handling API:

open System.Runtime.InteropServices
let ctrlSignal = ref false
[<DllImport("kernel32.dll")>]
extern void SetConsoleCtrlHandler(ControlEventHandler callback,bool add)

let ctrlEventHandler = new ControlEventHandler(fun i ->  ctrlSignal := true; true)

SetConsoleCtrlHandler(ctrlEventHandler,true)

Occasionally, you need to define a new .NET enum type in F#. You do this using a notation similar to discriminated unions:

type Vowels =
    | A = 1
    | E = 5
    | I = 9
    | O = 15
    | U = 21

This type is compiled as a .NET enum whose underlying bit representation is a simple integer.