F# Interfaces

F# interfaces are a way to define a contract for a type. They specify a set of members that a type must implement. F# interfaces are similar to interfaces in other object-oriented languages, but they have a few unique features.

Declaring an Interface

To declare an interface in F#, use the interface keyword. The syntax is similar to that of declaring a class.

type IMyInterface =
    abstract member MyMethod : int -> int
    abstract member MyProperty : int with get, set

This interface, IMyInterface, specifies two members that implementing types must have: a method called MyMethod that takes an int and returns an int, and a property called MyProperty that is an int.

Implementing an Interface

To implement an interface in F#, a type must use the interface keyword followed by the interface name.

type MyClass() =
    interface IMyInterface with
        member x.MyMethod i = i * i
        member x.MyProperty
            with get() = 0
            and set(value) = ()

The MyClass type implements IMyInterface. It provides implementations for MyMethod and MyProperty.

Using an Interface

A type that implements an interface can be used anywhere that the interface is required. For example, if a function takes an IMyInterface as a parameter, any type that implements IMyInterface can be passed.

let useMyInterface (i: IMyInterface) =
    printfn "MyProperty is %d" (i.MyProperty)
    printfn "MyMethod of 4 is %d" (i.MyMethod 4)

The useMyInterface function takes an IMyInterface and calls MyProperty and MyMethod on it.

Explicit Interface Implementation

F# allows for explicit interface implementations. This means that a type can implement an interface, but not expose the interface's members as public members of the type. Instead, their syntax is a bit different:

type MyClass2() =
    interface IMyInterface with
        member x.MyMethod i = i * i
        member x.MyProperty
            with get() = 0
            and set(value) = ()

    member x.IMyInterface.MyMethod i = i + i

Here, MyClass2 implements IMyInterface and also implements MyMethod from IMyInterface. However, MyMethod is not exposed as a public member of MyClass2. Instead, it can only be accessed through IMyInterface.

Conclusion

F# interfaces provide a way to define contracts between types. They allow for polymorphism and abstraction, making code more flexible and easier to maintain. With interfaces, we can create reusable code that can work with a variety of types.