Why let and var distinction matters in Swift - Why It Works This Way

Overview - Why let and var distinction matters

What is it?

In Swift, 'let' and 'var' are keywords used to declare variables. 'let' creates a constant, meaning its value cannot change once set. 'var' creates a variable, allowing its value to be changed later. This distinction helps manage data that should stay the same versus data that can change.

Why it matters

This distinction exists to help programmers write safer and clearer code. Without it, all variables could be changed accidentally, leading to bugs and unpredictable behavior. By using 'let' for values that should not change, Swift helps prevent mistakes and makes the code easier to understand and maintain.

Where it fits

Before learning this, you should understand what variables and constants are in programming. After this, you can learn about Swift’s type system, optionals, and how immutability affects functions and data structures.

Mental Model

Core Idea

'let' means fixed value that never changes, 'var' means value that can change anytime.

Think of it like...

Think of 'let' as writing with a permanent marker on paper — once written, it cannot be erased or changed. 'var' is like writing with a pencil — you can erase and rewrite as many times as you want.

┌───────────────┐       ┌───────────────┐
│   let (const) │──────▶│ Value fixed   │
└───────────────┘       └───────────────┘
         ▲                      ▲
         │                      │
┌───────────────┐       ┌───────────────┐
│   var (var)   │──────▶│ Value changes │
└───────────────┘       └───────────────┘

Build-Up - 7 Steps

1

Foundation

Understanding Variables and Constants

Concept: Introduce the basic idea of storing data with variables and constants.

In programming, a variable is a name that holds a value which can change. A constant is a name that holds a value which cannot change after it is set. Swift uses 'var' to declare variables and 'let' to declare constants.

Result

You know how to declare a variable and a constant in Swift using 'var' and 'let'.

Understanding the difference between changeable and fixed data is the foundation for writing predictable code.

2

Foundation

Declaring let and var in Swift

Concept: Learn the syntax and basic usage of 'let' and 'var' in Swift.

Example: let name = "Alice" // constant, cannot change var age = 30 // variable, can change Trying to change 'name' later will cause an error, but 'age' can be updated.

Result

You can write code that declares constants and variables and understand which can be changed.

Knowing the syntax lets you control which data can be modified, preventing accidental changes.

3

Intermediate

Why Immutability Matters for Safety

🤔Before reading on: do you think using 'let' can help prevent bugs or is it just a style choice? Commit to your answer.

Concept: Using 'let' makes data immutable, which helps avoid accidental changes and bugs.

When you declare something with 'let', Swift enforces that its value cannot be changed. This means if you try to assign a new value, the compiler will show an error. This helps catch mistakes early, making your code safer and more reliable.

Result

Code with 'let' is safer because it prevents unintended changes at compile time.

Understanding immutability helps you write code that is easier to debug and reason about.

4

Intermediate

Performance Benefits of let

🤔Before reading on: do you think using 'let' can affect how fast your program runs? Commit to your answer.

Concept: Constants declared with 'let' can allow the compiler to optimize code for better performance.

Because 'let' values never change, Swift can make assumptions and optimize memory and CPU usage. For example, it can store constants in faster memory or avoid unnecessary checks. Variables declared with 'var' require more flexible handling.

Result

Using 'let' can make your program run faster and use less memory in some cases.

Knowing that immutability can improve performance encourages you to prefer 'let' when possible.

5

Intermediate

let and var with Collections

🤔Before reading on: if you declare an array with 'let', can you add or remove items? Commit to your answer.

Concept: Understanding how 'let' and 'var' affect collections like arrays and dictionaries.

Declaring a collection with 'let' means you cannot change the collection itself (like adding or removing items), but if the items are reference types, their internal data can still change. Declaring with 'var' allows changing the collection structure.

Result

You know when collections are truly immutable and when their contents can still change.

Understanding this subtlety prevents bugs related to unexpected data changes in collections.

6

Advanced

let and var in Structs and Classes

🤔Before reading on: does 'let' prevent all changes inside a class instance? Commit to your answer.

Concept: How 'let' and 'var' behave differently with value types (structs) and reference types (classes).

For structs (value types), declaring with 'let' means the entire instance is immutable. For classes (reference types), 'let' means the reference cannot change, but the object's properties can still be modified if they are variables.

Result

You understand how immutability applies differently to structs and classes.

Knowing this helps avoid confusion about what can change when using 'let' with different types.

7

Expert

Compiler Enforcement and Memory Safety

🤔Before reading on: do you think the compiler can catch all changes to 'let' constants at compile time? Commit to your answer.

Concept: How Swift’s compiler enforces 'let' immutability and its role in memory safety.

Swift’s compiler tracks 'let' constants and prevents reassignment at compile time. This enforcement helps avoid undefined behavior and memory corruption. However, for reference types, internal mutability can still occur, which requires careful design to maintain safety.

Result

You see how 'let' contributes to Swift’s strong safety guarantees and where its limits are.

Understanding compiler enforcement clarifies why 'let' is a powerful tool but not a complete guarantee of immutability.

Under the Hood

When you declare a constant with 'let', the Swift compiler marks the memory location as immutable. This means any attempt to write to that memory after initialization is caught as a compile-time error. For variables declared with 'var', the compiler allows writes to the memory location. For value types like structs, the entire data is copied on assignment, preserving immutability for 'let' instances. For reference types like classes, 'let' only fixes the reference pointer, not the object's internal state.

Why designed this way?

Swift was designed with safety and clarity in mind. By distinguishing constants and variables explicitly, it encourages developers to think about data mutability upfront. This reduces bugs caused by unintended changes and enables compiler optimizations. Other languages often treat all variables as mutable by default, leading to more runtime errors. Swift’s approach balances safety with flexibility.

┌───────────────┐       ┌───────────────┐
│   let x = 5  │──────▶│ Immutable     │
│ (constant)   │       │ memory        │
└───────────────┘       └───────────────┘
         │                      ▲
         │                      │
┌───────────────┐       ┌───────────────┐
│   var y = 10 │──────▶│ Mutable       │
│ (variable)   │       │ memory        │
└───────────────┘       └───────────────┘

For structs:
let s = Struct()  (entire struct is immutable)

For classes:
let c = Class()   (reference fixed, object mutable)

Myth Busters - 4 Common Misconceptions

Quick: Does declaring a class instance with 'let' make all its properties immutable? Commit to yes or no.

Common Belief: Declaring a class instance with 'let' means nothing inside it can change.

Reality: Declaring a class instance with 'let' only means the reference cannot change; the object's properties can still be modified if they are variables.

Why it matters: Believing this can lead to unexpected bugs when internal state changes even though the reference is constant.

Quick: If you declare an array with 'let', can you add or remove elements? Commit to yes or no.

Common Belief: An array declared with 'let' can still have elements added or removed.

Reality: An array declared with 'let' is immutable; you cannot add, remove, or replace elements after initialization.

Why it matters: Misunderstanding this causes runtime errors and confusion about why code modifying the array fails.

Quick: Does using 'let' always improve performance? Commit to yes or no.

Common Belief: Using 'let' always makes code run faster.

Reality: While 'let' can enable optimizations, the performance gain depends on context and is not guaranteed in every case.

Why it matters: Expecting automatic speed improvements can lead to misplaced optimization efforts.

Quick: Is 'let' just a style choice with no real impact? Commit to yes or no.

Common Belief: 'let' is only for code style and readability, not safety or correctness.

Reality: 'let' enforces immutability at compile time, preventing bugs and enabling optimizations.

Why it matters: Ignoring 'let' can lead to more bugs and harder-to-maintain code.

Expert Zone

1

Using 'let' with reference types only fixes the reference, not the object's internal state, which can still be mutable.

2

Swift’s compiler uses 'let' declarations to perform aggressive optimizations like constant folding and inlining.

3

In concurrent code, 'let' constants help avoid race conditions by guaranteeing immutability.

When NOT to use

Avoid using 'let' when you need to change the value after initialization, such as counters, accumulators, or user input variables. Use 'var' in these cases. For complex mutable state, consider using classes or specialized concurrency-safe types instead of relying solely on 'var'.

Production Patterns

In production Swift code, developers prefer 'let' by default and only use 'var' when necessary. This practice reduces bugs and improves code clarity. Immutable data structures combined with 'let' are common in functional programming styles within Swift. Also, 'let' is heavily used in SwiftUI to define constant views and state.

Connections

Immutable Data Structures

Builds-on

Understanding 'let' helps grasp how immutable data structures work, which are key for safe and predictable programs.

Functional Programming

Builds-on

The use of 'let' aligns with functional programming principles that emphasize immutability to avoid side effects.

Mathematics - Constants vs Variables

Same pattern

Just like in math where constants never change and variables can, 'let' and 'var' reflect this fundamental distinction in programming.

Common Pitfalls

#1 Trying to change a constant declared with 'let'.

Wrong approach:

let pi = 3.14
pi = 3.14159 // Error: Cannot assign to value: 'pi' is a 'let' constant

Correct approach:

var pi = 3.14
pi = 3.14159 // Allowed because 'pi' is a variable

Root cause:

Misunderstanding that 'let' creates an immutable constant that cannot be reassigned.

#2 Declaring a collection with 'let' and then trying to modify it.

Wrong approach:

let numbers = [1, 2, 3]
numbers.append(4) // Error: Cannot use mutating member on immutable value

Correct approach:

var numbers = [1, 2, 3]
numbers.append(4) // Allowed because 'numbers' is a variable

Root cause:

Not realizing that 'let' makes the entire collection immutable, preventing structural changes.

#3 Assuming 'let' makes class properties immutable.

Wrong approach:

class Person {
var name: String
init(name: String) { self.name = name }
}
let person = Person(name: "Alice")
person.name = "Bob" // Allowed, no error

Correct approach:

Use 'let' for properties inside the class to make them immutable:
class Person {
let name: String
init(name: String) { self.name = name }
}
let person = Person(name: "Alice")
person.name = "Bob" // Error: Cannot assign to property: 'name' is a 'let' constant

Root cause:

Confusing immutability of the reference with immutability of the object's properties.

Key Takeaways

'let' declares constants whose values cannot change, while 'var' declares variables that can change.

Using 'let' helps prevent bugs by enforcing immutability at compile time.

The distinction between 'let' and 'var' enables compiler optimizations and safer code.

Understanding how 'let' works with value and reference types is key to avoiding common mistakes.

Prefer 'let' by default and use 'var' only when you need to change the value.