Enum with switch pattern matching in Swift - Cheat Sheet & Quick Revision

Recall & Review

beginner

What is an enum in Swift?

An enum (short for enumeration) is a type that groups related values under a common name. It helps organize code by defining a set of possible cases.

beginner

How does switch pattern matching work with enums in Swift?

Switch pattern matching lets you check which enum case a value matches and run code for that case. It can also extract associated values if the enum has them.

intermediate

What happens if you don’t cover all enum cases in a switch statement?

Swift requires all enum cases to be handled in a switch. If not, you must add a default case or the code won’t compile.

intermediate

How do you extract associated values from an enum case in a switch?

Use case pattern matching with let or var to bind the associated values to variables inside the switch case.

beginner

Example: What does this code print?
<pre>enum Direction { case north, south, east, west }
let dir = Direction.east
switch dir {
 case .north: print("Up")
 case .south: print("Down")
 case .east: print("Right")
 case .west: print("Left")
}</pre>

It prints "Right" because the value dir is .east and the switch matches that case.

What keyword is used to define an enum in Swift?

A class

B struct

C enum

D type

The keyword 'enum' is used to define an enumeration in Swift.

What must a switch statement do when matching an enum?

A Handle all enum cases or include a default case

B Only handle one case

C Ignore cases without code

D Use if-else instead

Swift requires switch statements to be exhaustive, meaning all enum cases must be handled or a default case must be provided.

How do you access associated values in a switch case?

A Use a function call

B Use let or var to bind values in the case pattern

C Use dot notation outside the switch

D You cannot access associated values

You use let or var inside the case pattern to extract associated values from an enum case.

Which of these is a valid enum case pattern in a switch?

A case .north:

B case north:

C case Direction.north:

D case "north":

Inside a switch on an enum, you use the shorthand '.caseName' to match cases.

What will happen if you forget to handle an enum case in a switch without a default?

A Code runs but skips missing cases

B Runtime error

C Switch ignores missing cases

D Compilation error

Swift enforces exhaustiveness in switch statements on enums, so missing cases cause a compile-time error.

Explain how to use switch pattern matching with enums in Swift, including handling associated values.

Think about how you check each case and get values out if needed.

Describe why Swift requires switch statements on enums to be exhaustive and how you can satisfy this requirement.

Consider safety and completeness in your code.

Practice

1. What is the main purpose of using an enum with associated values in Swift?

easy

A. To group related values and store extra data in each case

B. To create a class with multiple methods

C. To define a function that returns multiple values

D. To declare a variable that can only hold integers

Solution

1. Step 1: Understand enum basics

   An enum groups related values under one type, making code organized.

2. Step 2: Recognize associated values

   Enums with associated values can store extra data for each case, like a label or number.

3. Final Answer:

   To group related values and store extra data in each case -> Option A

4. Quick Check:

   Enum with associated values = group + extra data [OK]

Hint: Enums group related data with extra info easily [OK]

Common Mistakes:

• Confusing enums with classes
• Thinking enums only hold fixed values
• Assuming enums are functions

2. Which of the following is the correct syntax to match an enum case with associated values using switch in Swift?

easy

A. case .someCase(let value):

B. case someCase = value:

C. case .someCase => value:

D. case someCase(value) {

Solution

1. Step 1: Recall switch case syntax for enums

   In Swift, to match an enum case with associated values, use case .caseName(let variable):.

2. Step 2: Identify correct pattern

   case .someCase(let value): uses the correct dot syntax and binding with let.

3. Final Answer:

   case .someCase(let value): -> Option A

4. Quick Check:

   Switch enum case with let binding = case .someCase(let value): [OK]

Hint: Use dot and let to bind enum associated values [OK]

Common Mistakes:

• Missing dot before case name
• Using = instead of :
• Wrong arrow or braces syntax

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

enum Direction {
    case north, south, east, west
}

let dir = Direction.east

switch dir {
case .north:
    print("Going North")
case .south:
    print("Going South")
case .east:
    print("Going East")
case .west:
    print("Going West")
}

medium

A. No output

B. Going North

C. Going West

D. Going East

Solution

1. Step 1: Identify enum value assigned

   The variable dir is assigned Direction.east.

2. Step 2: Match switch case

   The switch matches .east case and prints "Going East".

3. Final Answer:

   Going East -> Option D

4. Quick Check:

   dir = east prints "Going East" [OK]

Hint: Match enum value to switch case to find output [OK]

Common Mistakes:

• Confusing enum case names
• Forgetting to include all cases
• Assuming default case runs

4. Identify the error in this Swift code using enum and switch:

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

let res = Result.success(10)

switch res {
case .success(let value):
    print("Value: \(value)")
case failure(let message):
    print("Error: \(message)")
}

medium

A. Switch statement missing default case

B. Wrong associated value type for 'success'

C. Missing dot before 'failure' in switch case

D. Enum cases cannot have associated values

Solution

1. Step 1: Check switch case syntax

   In switch, enum cases must be prefixed with a dot, like .failure.

2. Step 2: Identify missing dot

   The second case uses failure without a dot, causing a syntax error.

3. Final Answer:

   Missing dot before 'failure' in switch case -> Option C

4. Quick Check:

   Enum case in switch needs dot prefix [OK]

Hint: Always prefix enum cases with dot in switch [OK]

Common Mistakes:

• Omitting dot before enum case in switch
• Confusing associated value types
• Forgetting to handle all cases

5. Given this enum and function, what will describeShape(.rectangle(width: 5, height: 10)) print?

enum Shape {
    case circle(radius: Double)
    case rectangle(width: Double, height: Double)
    case point
}

func describeShape(_ shape: Shape) {
    switch shape {
    case .circle(let r):
        print("Circle with radius \(r)")
    case .rectangle(let w, let h):
        print("Rectangle \(w) x \(h)")
    case .point:
        print("Just a point")
    }
}

hard

A. Circle with radius 5.0

B. Rectangle 5.0 x 10.0

C. Just a point

D. Syntax error in switch

Solution

1. Step 1: Identify enum case and associated values

   The input is .rectangle(width: 5, height: 10), so width = 5 and height = 10.

2. Step 2: Match switch case and print

   The switch matches .rectangle(let w, let h) and prints "Rectangle 5.0 x 10.0".

3. Final Answer:

   Rectangle 5.0 x 10.0 -> Option B

4. Quick Check:

   Rectangle case prints dimensions [OK]

Hint: Match enum case and extract all associated values [OK]

Common Mistakes:

• Using wrong variable names in case
• Missing multiple associated values in pattern
• Assuming default case runs