In this section, we will explore two fundamental concepts in F#: functions and immutability. These concepts are at the core of functional programming and are essential for writing effective and efficient F# code.

Functions are first-class citizens in F#. This means that functions can be passed as arguments, returned from other functions, and assigned to variables. Let's break down the key concepts related to functions in F#.

Functions in F# can be defined using the let keyword. Here is a simple example:

In this example:

• let is used to define a function.
• add is the name of the function.
• x and y are parameters.
• x + y is the body of the function.

The type of a function is determined by the types of its parameters and its return type. For example, the type of the add function is int -> int -> int, which means it takes two integers and returns an integer.

Anonymous functions (also known as lambda functions) can be defined using the fun keyword. Here is an example:

This is equivalent to:

Higher-order functions are functions that take other functions as arguments or return functions as results. Here is an example:

In this example:

• applyFunction is a higher-order function.
• f is a function that is passed as an argument.
• x is the value to which the function f is applied.

Let's see a practical example of using functions in F#:

In this example:

• square is a function that squares a number.
• sumOfSquares is a function that calculates the sum of the squares of two numbers.
• result stores the result of sumOfSquares 3 4, which is 25.

Immutability is a core principle in functional programming. In F#, once a value is assigned to a variable, it cannot be changed. This helps to avoid side effects and makes the code more predictable and easier to debug.

Variables in F# are immutable by default. Here is an example:

In this example:

• x is assigned the value 10.
• Attempting to reassign x will result in a compile-time error.

If you need to change the value of a variable, you can use the mutable keyword. However, this should be used sparingly. Here is an example:

In this example:

• y is declared as mutable.
• The value of y is changed to 20.

Let's see a practical example of immutability in F#:

In this example:

• increment is a function that increments a number.
• originalValue is assigned the value 5.
• newValue is assigned the result of increment originalValue, which is 6.
• The original value remains unchanged, demonstrating immutability.

Define a function subtract that takes two integers and returns their difference.

Solution:

Define a higher-order function applyTwice that takes a function f and a value x, and applies f to x twice.

Solution:

Create an immutable variable z with the value 15. Then, create a new variable newZ that is the result of adding 5 to z.

Solution:

In this section, we covered:

• How to define and use functions in F#.
• The concept of higher-order functions.
• The importance of immutability in functional programming.
• Practical examples and exercises to reinforce the concepts.

Understanding functions and immutability is crucial for mastering F#. In the next section, we will delve into pattern matching, another powerful feature of F#.