F# Objects and Classes

F# is a functional programming language, but it also supports object-oriented programming through the use of objects and classes. In this guide, we will explore how to create and use objects and classes in F#.

Creating Objects

Objects in F# are created by defining a class and then instantiating it. Here's an example:

type Person(name: string, age: int) =
    member this.Name = name
    member this.Age = age

let john = Person("John", 30)

In this example, we define a Person class that takes two parameters, name and age. We then create an instance of this class by calling Person("John", 30) and assign it to the variable john.

Accessing Object Members

We can access the members of an object using the dot notation. For example:

let name = john.Name
let age = john.Age

In this example, we access the Name and Age members of the john object and assign them to the variables name and age.

Inheritance

F# supports inheritance, which allows us to create a new class that is derived from an existing class. Here's an example:

type Employee(name: string, age: int, id: int) =
    inherit Person(name, age)
    member this.Id = id

let jane = Employee("Jane", 25, 1234)
let janeName = jane.Name
let janeId = jane.Id

In this example, we define an Employee class that is derived from the Person class. We add a new member Id to the Employee class. We then create an instance of the Employee class and assign it to the variable jane. We can access the Name and Id members of the jane object using the dot notation.

Interface

F# also supports interfaces, which allow us to define a common set of members that can be implemented by multiple classes. Here's an example:

type IPrintable =
    abstract member Print : unit -> unit

type Person(name: string, age: int) =
    interface IPrintable with
        member this.Print() =
            printfn "%s (%d)" this.Name this.Age
    member this.Name = name
    member this.Age = age

let john = Person("John", 30)
john.Print()

In this example, we define an IPrintable interface that defines a single member Print. We then define a Person class that implements the IPrintable interface. We create an instance of the Person class and call the Print method on it.

Conclusion

As we can see, F# supports object-oriented programming through the use of objects, classes, inheritance, and interfaces. These features allow us to create robust and maintainable code that can be easily extended and reused.