Imperative Programming and Mutable Values

Similarly as ML and OCaml, F# adopts an eager evaluation mechanism, which means that a code written using sequencing operator is executed in the same order in which it is written and expressions given as an arguments to a function are evaluated before calling the function (this mechanism is used in most imperative languages including C#, Java or Python). This makes it semantically reasonable to support imperative programming features in a functional language. As already mentioned, the F# value bindings are by default immutable, so to make a variable mutable the mutable keyword has to be used. Additionally F# supports a few imperative language constructs (like for and while), which are expressions of type unit:


> // Imperative factorial calculation
let n = 10
let mutable res = 1
for n = 2 to n do
res <- res * n
// Return the result
res;;
val it : int = 3628800


The use of the eager evaluation and the ability to use mutable values makes it very easy to interoperate with other .NET languages (that rely on the use of mutable state), which is an important aspect of the F# language. In addition it is also possible to use the mutable keyword for creating a record type with a mutable field.

Arrays

As mentioned earlier, another type of value that can be mutated is .NET array. Arrays can be either created using [| .. |] expressions (in the following example we use it together with a range expression, which initializes an array with a range) or using functions from the Array module, for example Array.create. Similarly to the mutable variables introduced in the previous section, the value of an array element can be modified using the <- operator:

> let arr = [| 1 .. 10 |]
val arr : array
> for i = 0 to 9 do
arr.[i] <- 11 - arr.[i]
(...)
> arr;;
val it : array = [| 10; 9; 8; 7; 6; 5; 4; 3; 2; 1 |]