In this module, we will explore the object-oriented programming (OOP) capabilities of F#. While F# is primarily a functional programming language, it also supports OOP, allowing you to create classes, objects, and use inheritance and interfaces. This flexibility makes F# a powerful tool for a wide range of programming tasks.

1. Classes: Define the blueprint for objects, encapsulating data and behavior.
2. Objects: Instances of classes that hold specific data and can perform actions defined by their class.
3. Constructors: Special methods used to initialize objects.
4. Members: Properties and methods that belong to a class.
5. Inheritance: Mechanism to create a new class from an existing class, inheriting its members.
6. Interfaces: Define a contract that classes can implement, ensuring they provide specific functionality.

In F#, you define a class using the type keyword followed by the class name and a set of members. Here's a simple example:

• type Person(name: string, age: int) defines a class named Person with two parameters: name and age.
• member this.Name = name and member this.Age = age define properties for the class.
• member this.Introduce() defines a method that prints a greeting message.

To create an instance of the Person class, you use the new keyword:

• let person = new Person("Alice", 30) creates a new Person object with the name "Alice" and age 30.
• person.Introduce() calls the Introduce method on the person object.

F# supports primary and secondary constructors. The primary constructor is defined in the class signature, while secondary constructors are defined using the new keyword within the class.

The primary constructor is already shown in the Person class example above.

Here's an example of a class with a secondary constructor:

• new(make, model, year) defines a secondary constructor.
• Car(make, model) calls the primary constructor.
• then year <- year initializes the year field.

Inheritance allows a class to inherit members from another class. In F#, you use the inherit keyword.

• type Animal(name: string) defines a base class Animal.
• type Dog(name: string, breed: string) defines a derived class Dog that inherits from Animal.
• inherit Animal(name) calls the base class constructor.

Interfaces define a contract that classes can implement. In F#, you use the interface keyword.

• type IShape defines an interface with two abstract members: Area and Perimeter.
• type Rectangle(width: float, height: float) defines a class that implements the IShape interface.
• interface IShape with provides the implementation for the interface members.

1. Define a class Book with properties Title, Author, and Pages.
2. Add a method Summary that prints a summary of the book.
3. Create an object of the Book class and call the Summary method.

• type Book(title: string, author: string, pages: int) defines the Book class.
• member this.Summary() defines the Summary method.
• let book = new Book("The Great Gatsby", "F. Scott Fitzgerald", 180) creates a Book object.
• book.Summary() calls the Summary method.

In this module, we covered the basics of classes and objects in F#. We learned how to define classes, create objects, use constructors, and implement inheritance and interfaces. These concepts are fundamental to object-oriented programming and provide a solid foundation for more advanced topics.

Next, we will explore inheritance and interfaces in more detail, allowing you to create more complex and reusable code structures.