What are the benefits of `let` in Swift?

Question

I know Swift does encourage us programmers to use constants (let) instead of variables (var) everytime it makes sense.

This is a good thing because we are providing more details to the compiler about what our code means and the compiler can better prevent us from making mistakes (e.g. changing some value that should not be changed).

My question is, are there some performance optimizations the compiler does apply when we use constants instead of variables? (e.g. faster executions times, lower footprint, ...).

Answer 1

You asked "...are there some performance optimisations the compiler does apply when we use constants instead of variables?"

The answer is yes, absolutely.

Mutable collections may be organized differently than immutable ones in order to allow for them to be changed. Immutable collections can be optimized for read-only operation.

Then there is the use of mutable/immutable objects. The compiler may have to generate code that copies a mutable object when it's shared as a property of another object in order to avoid undesired side-effects.

Comparison of immutable objects (equatable/comparable) can also be optimized in ways that mutable objects can't.

Sulthan's point about the intelligence of the compiler is a good one though. The compiler can often deduce that a variable is never going to change from code analysis, which can make benchmarking let vs. var usage hard.