F# uses the let keyword for the declaration of a variable, for example:

let square x = x*x

The compiler automatically detects this as a value type. If we pass a float value, the compiler will be able to understand that without declaring a data type. Variables in F# are immutable, so once a value is assigned to a variable, it can't be changed. They are compiled as static read-only properties.

The following example demonstrates this:

let x:int32 = 50
let y:int32 = 30
let z:int32 = x + y

Variables x, y, and z are all of type int32 and are immutable, meaning their value cannot be changed.

Let's print their values. The syntax is as follows:

printfn "x: %i" x
printfn "y: %i" y
printfn "z: %i" z

After the preceding code executes, the result is as follows:

x: 50
y: 30
z: 80

Now, suppose we want to modify the value of x from 50 to 60 and check that z reflects the updated sum; we will write the code as:

let x = 60
let y = 30
let z = x + y

On executing this code, we get the following errors, and rightly so because x and z are immutable:

Duplicate definition of value 'x'
Duplicate definition of value 'z'

The correct way of doing it would be to use mutable variables for the declaration, as shown here:

let mutable x = 60
let y = 30 //It's optional to make y mutable.
let mutable z = x + y
x <- 70
z <-  x + y

On printing the values again, we will see:

x: 70
y: 30
z: 100