Collection mutability tied to let/var in Swift - Step-by-Step Execution

Concept Flow - Collection mutability tied to let/var

Declare collection with let or var

↓

Is collection declared with let?

↓

Collection is immutable

↓

Attempt to modify?

↓

Error: Cannot modify

This flow shows how declaring a collection with let makes it immutable, so modifications cause errors, while var allows changes.

Execution Sample

Swift

let numbers = [1, 2, 3]
numbers.append(4) // Error

var fruits = ["apple", "banana"]
fruits.append("cherry") // Works

Shows that a collection declared with let cannot be changed, but one declared with var can be modified.

Execution Table

Step	Declaration	Collection State	Action	Result
1	let numbers = [1, 2, 3]	[1, 2, 3]	Declare immutable array	Success
2	numbers.append(4)	[1, 2, 3]	Try to append 4	Error: Cannot modify immutable collection
3	var fruits = ["apple", "banana"]	["apple", "banana"]	Declare mutable array	Success
4	fruits.append("cherry")	["apple", "banana"]	Append "cherry"	Success: ["apple", "banana", "cherry"]

💡 Compile-time error occurs at step 2 because immutable collection cannot be modified. Steps 3-4 demonstrate the mutable case.

Variable Tracker

Variable	Start	After 1	After 2	After 3	After 4	Final
numbers	undefined	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]	[1, 2, 3]
fruits	undefined	undefined	undefined	["apple", "banana"]	["apple", "banana", "cherry"]	["apple", "banana", "cherry"]

Key Moments - 3 Insights

Why does appending to 'numbers' cause an error even though it's an array?

Because 'numbers' is declared with let, making the entire collection immutable. Step 2 in the execution_table shows the error when trying to modify it.

Can you modify elements inside a collection declared with let?

No, the collection is fully immutable. You cannot add, remove, or change elements. This is shown in step 2 where append fails.

Why does appending to 'fruits' work without error?

Because 'fruits' is declared with var, which allows the collection to be mutable. Step 4 shows the successful append operation.

Visual Quiz - 3 Questions

Look at the execution_table, what is the state of 'numbers' after step 2?

A [1, 2, 3, 4]

B [1, 2, 3]

C Error state, no change

D Undefined

💡 Hint

Refer to the 'Collection State' column in step 2 of the execution_table.

At which step does the collection become mutable and allow modification?

A Step 3

B Step 2

C Step 1

D Step 4

💡 Hint

Check the 'Declaration' and 'Result' columns in the execution_table.

If 'numbers' was declared with var instead of let, what would happen at step 2?

A Compilation error at declaration

B Error: Cannot modify immutable collection

C Append succeeds, collection becomes [1, 2, 3, 4]

D No change, append ignored

💡 Hint

Compare step 2 and step 4 in the execution_table for mutable vs immutable collections.

Concept Snapshot

Declare collections with let or var.
let = immutable collection, no changes allowed.
var = mutable collection, can add/remove elements.
Trying to modify let collection causes error.
Use var when you need to change the collection.

Full Transcript

In Swift, collections like arrays are mutable or immutable depending on how you declare them. If you use let, the collection is immutable, meaning you cannot add, remove, or change elements. Trying to modify such a collection causes a compile-time error. If you declare the collection with var, it is mutable and you can modify it freely. This example shows an array declared with let that causes an error when appending, and another declared with var that allows appending successfully.