Associated values per case in Swift - Step-by-Step Execution

Concept Flow - Associated values per case

Define enum with cases

↓

Create enum instance with associated value

↓

Switch on enum instance

↓

Match case and extract associated value

↓

Use associated value in code

This flow shows how to define an enum with associated values, create an instance, switch on it, and extract the associated value for use.

Execution Sample

Swift

enum Result {
    case success(String)
    case failure(Int)
}

let res = Result.success("Done")
switch res {
case .success(let message): print(message)
case .failure(let code): print(code)
}

This code defines an enum with associated values, creates a success case with a message, and prints the message by matching the case.

Execution Table

Step	Action	Evaluation	Result
1	Define enum Result with cases success(String) and failure(Int)	N/A	Enum type created
2	Create instance res = Result.success("Done")	N/A	res holds success case with "Done"
3	Switch on res	res is success("Done")	Match .success case
4	Extract associated value with let message	message = "Done"	message variable set
5	Print message	print("Done")	Output: Done
6	Exit switch	No more cases	Switch ends

💡 Switch ends after matching the .success case and printing the associated value

Variable Tracker

Variable	Start	After Step 2	After Step 4	Final
res	undefined	success("Done")	success("Done")	success("Done")
message	undefined	undefined	"Done"	"Done"

Key Moments - 2 Insights

Why do we use 'let message' inside the case instead of just using '.success'?

Because '.success' is the case name, and 'message' is the associated value inside it. The switch extracts the associated value by naming it with 'let message' as shown in step 4 of the execution_table.

What happens if we try to access the associated value without switching on the enum?

You cannot directly access the associated value without matching the case in a switch or if-case. The enum instance holds the value internally, so you must extract it as shown in steps 3 and 4.

Visual Quiz - 3 Questions

Look at the execution_table, what is the value of 'message' after step 4?

A success("Done")

B "Done"

C undefined

D Int value

💡 Hint

Check the variable_tracker row for 'message' after step 4

At which step does the switch statement match the .success case?

A Step 3

B Step 2

C Step 4

D Step 5

💡 Hint

Look at the execution_table row where the switch evaluates the enum instance

If the enum instance was Result.failure(404), what would be printed?

A "Done"

B No output

C 404

D Error

💡 Hint

Think about the failure case and its associated Int value

Concept Snapshot

enum MyEnum {
  case one(Type)
  case two(Type)
}

Create instance: let val = MyEnum.one(value)

Switch and extract:
switch val {
 case .one(let x): use x
 case .two(let y): use y
}

Use associated values to store extra info per case.

Full Transcript

This example shows how to use Swift enums with associated values. First, we define an enum with cases that hold extra data. Then, we create an instance of the enum with one case and its associated value. Next, we use a switch statement to check which case the instance holds. Inside the matching case, we extract the associated value using 'let' and use it, for example, by printing it. The execution table traces each step, showing how variables change and how the switch matches the case. Key moments clarify why we extract values inside the switch and why direct access is not possible. The quiz tests understanding of variable values and switch matching. The snapshot summarizes the syntax and usage for quick reference.

Practice

1. What is the main purpose of associated values in Swift enums?

easy

A. To store extra data with each enum case

B. To define multiple enums in one declaration

C. To create functions inside enums

D. To inherit properties from other enums

Solution

1. Step 1: Understand enum cases

   Enum cases represent fixed options, but sometimes need extra data.

2. Step 2: Role of associated values

   Associated values let each case carry extra information, like a label or number.

3. Final Answer:

   To store extra data with each enum case -> Option A

4. Quick Check:

   Associated values = extra data per case [OK]

Hint: Think: extra info stored inside enum cases [OK]

Common Mistakes:

• Confusing associated values with raw values
• Thinking enums can inherit properties
• Believing enums can contain functions only

2. Which of the following is the correct syntax to define an enum case with an associated value of type String?

easy

A. case name -> String

B. case name(String)

C. case name: String

D. case name = String

Solution

1. Step 1: Recall enum case syntax with associated values

   Associated values use parentheses after the case name with the type inside.

2. Step 2: Match syntax options

   Only 'case name(String)' uses parentheses correctly for associated values.

3. Final Answer:

   case name(String) -> Option B

4. Quick Check:

   Parentheses hold associated value type [OK]

Hint: Use parentheses for associated value types [OK]

Common Mistakes:

• Using colon instead of parentheses
• Using equals sign for associated values
• Using arrow notation incorrectly

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

enum Result {
    case success(String)
    case failure(Int)
}

let response = Result.success("Done")
switch response {
case .success(let message):
    print(message)
case .failure(let code):
    print("Error code: \(code)")
}

medium

A. Error code: Done

B. Compilation error

C. Error code: 0

D. Done

Solution

1. Step 1: Identify enum case used

   The variable 'response' is assigned 'Result.success("Done")'.

2. Step 2: Switch matches .success case

   The switch matches '.success(let message)' and prints the message string.

3. Final Answer:

   Done -> Option D

4. Quick Check:

   Matching case prints associated string [OK]

Hint: Match enum case to print its associated value [OK]

Common Mistakes:

• Confusing success and failure cases
• Expecting error code instead of message
• Thinking code will not compile

4. Identify the error in this Swift enum usage:

enum Device {
    case phone(model: String)
    case tablet(model: String)
}

let myDevice = Device.phone("iPhone")

medium

A. Missing parentheses around associated value

B. Enum cases cannot have associated values

C. Cannot assign associated value without label

D. Incorrect enum declaration syntax

Solution

1. Step 1: Check enum case declaration

   Cases use labeled associated values: 'phone(model: String)'.

2. Step 2: Check enum instance assignment

   Assigning 'Device.phone("iPhone")' omits the label 'model:'.

3. Final Answer:

   Cannot assign associated value without label -> Option C

4. Quick Check:

   Labeled associated values require labels on assignment [OK]

Hint: Use labels when enum cases define labeled associated values [OK]

Common Mistakes:

• Ignoring labels in associated values
• Thinking parentheses are missing
• Believing enums can't have associated values

5. Given this enum with multiple associated values:

enum Message {
    case text(String, Int)
    case image(url: String, size: (width: Int, height: Int))
}

let msg = Message.image(url: "photo.png", size: (width: 100, height: 200))
switch msg {
case .text(let content, let length):
    print("Text: \(content), length: \(length)")
case .image(let url, let size):
    print("Image URL: \(url), size: \(size.width)x\(size.height)")
}

What will be printed?

hard

A. Image URL: photo.png, size: 100x200

B. Text: photo.png, length: 100

C. Image URL: photo.png, size: (100, 200)

D. Compilation error due to tuple

Solution

1. Step 1: Identify enum case and associated values

   Variable 'msg' is assigned '.image' with url and size tuple.

2. Step 2: Switch matches .image case and prints values

   Print statement accesses url and tuple's width and height correctly.

3. Final Answer:

   Image URL: photo.png, size: 100x200 -> Option A

4. Quick Check:

   Tuple values accessed with dot notation [OK]

Hint: Access tuple parts with dot notation inside switch [OK]

Common Mistakes:

• Printing tuple as whole instead of parts
• Confusing .text and .image cases
• Expecting compilation error from tuple