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.

Practice

1. In Swift, if you declare a collection with let, what does it mean for that collection?

easy

A. The collection cannot be changed after creation.

B. You can add or remove items anytime.

C. Only the items inside can change, but not the collection size.

D. The collection is deleted automatically.

Solution

1. Step 1: Understand let in Swift

   let creates a constant, meaning the value cannot be changed after it is set.

2. Step 2: Apply to collections

   If a collection is declared with let, you cannot add, remove, or modify its elements because the collection itself is constant.

3. Final Answer:

   The collection cannot be changed after creation. -> Option A

4. Quick Check:

   let means constant collection [OK]

Hint: Remember: let means no changes allowed to collection [OK]

Common Mistakes:

• Thinking you can add items to a let collection
• Confusing let with var for collections
• Assuming only items can change but not size

2. Which of the following is the correct way to declare a mutable array in Swift?

easy

A. mutable numbers = [1, 2, 3]

B. let numbers = [1, 2, 3]

C. const numbers = [1, 2, 3]

D. var numbers = [1, 2, 3]

Solution

1. Step 1: Recall Swift syntax for mutable collections

   Use var to declare variables that can change.

2. Step 2: Check options

   var numbers = [1, 2, 3] correctly declares a mutable array. let is immutable, and const or mutable are not Swift keywords.

3. Final Answer:

   var numbers = [1, 2, 3] -> Option D

4. Quick Check:

   Mutable array uses var [OK]

Hint: Use var for collections you want to change [OK]

Common Mistakes:

• Using let instead of var for mutable collections
• Using non-Swift keywords like const or mutable
• Confusing var with let

3. What will be the output of this Swift code?

let fruits = ["Apple", "Banana"]
fruits.append("Cherry")
print(fruits)

medium

A. Compile-time error

B. ["Apple", "Banana"]

C. ["Apple", "Banana", "Cherry"]

D. Runtime crash

Solution

1. Step 1: Identify collection mutability

   The array fruits is declared with let, making it immutable.

2. Step 2: Analyze append operation

   Trying to append to an immutable array causes a compile-time error because you cannot modify a constant collection.

3. Final Answer:

   Compile-time error -> Option A

4. Quick Check:

   Append on let collection = Compile-time error [OK]

Hint: Appending to let collection causes compile error [OK]

Common Mistakes:

• Assuming append works on let collections
• Thinking it crashes at runtime instead of compile-time
• Expecting original array unchanged

4. Consider this Swift code snippet:

let numbers = [1, 2, 3]
numbers[0] = 10
print(numbers)

What is the problem here?

medium

A. The array must be declared with var to print.

B. You cannot change elements of an array declared with let.

C. The print statement is incorrect.

D. Array index 0 does not exist.

Solution

1. Step 1: Check array declaration

   The array numbers is declared with let, so it is immutable.

2. Step 2: Understand element assignment

   Trying to assign a new value to an element of an immutable array is not allowed and causes a compile-time error.

3. Final Answer:

   You cannot change elements of an array declared with let. -> Option B

4. Quick Check:

   Changing element in let array = Not allowed [OK]

Hint: Elements of let arrays cannot be changed [OK]

Common Mistakes:

• Thinking only size is fixed but elements can change
• Assuming index 0 is invalid
• Believing print causes error

5. You want to create a dictionary in Swift that you can update later by adding or changing keys and values. Which declaration should you use and why?

hard

A. Use let and then create a new dictionary to update.

B. Use let because it allows changing keys and values.

C. Use var because it allows modifying the dictionary after creation.

D. Use var but you cannot change keys or values.

Solution

1. Step 1: Understand mutability of dictionaries

   To modify a dictionary after creation, it must be declared mutable.

2. Step 2: Choose correct keyword

   var declares a mutable dictionary allowing adding or changing keys and values. let makes it immutable.

3. Final Answer:

   Use var because it allows modifying the dictionary after creation. -> Option C

4. Quick Check:

   Mutable dictionary needs var [OK]

Hint: Use var for collections you want to update later [OK]

Common Mistakes:

• Using let and expecting to modify dictionary
• Thinking let allows changing keys or values
• Believing var prevents changing keys or values