Enum with switch pattern matching in Swift

Introduction

Enums let you group related values together. Switch pattern matching helps you check which value the enum holds and run code based on it.

You want to represent a fixed set of options, like days of the week or directions.

You need to run different code depending on the enum's current value.

You want clear and safe handling of different cases without errors.

You want to extract associated data from enum cases easily.

You want your code to be easy to read and maintain.

Syntax

Swift

enum EnumName {
    case case1
    case case2(AssociatedType)
    case case3
}

let value = EnumName.case1

switch value {
case .case1:
    // code for case1
case .case2(let data):
    // code using data
case .case3:
    // code for case3
}

Use case .caseName inside switch to match enum cases.

Use let to get associated values from enum cases.

Examples

Simple enum with no associated values. Switch matches each direction.

Swift

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

let travelDirection = Direction.north

switch travelDirection {
case .north:
    print("Going north")
case .south:
    print("Going south")
case .east:
    print("Going east")
case .west:
    print("Going west")
}

Enum with associated values. Switch extracts the data inside each case.

Swift

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

let operationResult = Result.success("File saved")

switch operationResult {
case .success(let message):
    print("Success: \(message)")
case .failure(let errorCode):
    print("Error code: \(errorCode)")
}

Another simple enum example showing clear switch cases.

Swift

enum Light {
    case red
    case yellow
    case green
}

let trafficLight = Light.red

switch trafficLight {
case .red:
    print("Stop")
case .yellow:
    print("Get ready")
case .green:
    print("Go")
}

Sample Program

This program defines a Weather enum with three cases. Some cases have extra data. The describe function uses switch pattern matching to print messages based on the weather. It shows how to handle each case clearly.

Swift

import Foundation

enum Weather {
    case sunny
    case rainy(Int)  // Int is mm of rain
    case windy(Double) // Double is wind speed
}

func describe(weather: Weather) {
    switch weather {
    case .sunny:
        print("It's a bright sunny day!")
    case .rainy(let mm):
        print("It's raining with \(mm) mm of rain.")
    case .windy(let speed):
        print("It's windy with speed \(speed) km/h.")
    }
}

let todayWeather = Weather.rainy(20)
print("Before switch:", todayWeather)
describe(weather: todayWeather)

let tomorrowWeather = Weather.sunny
print("Before switch:", tomorrowWeather)
describe(weather: tomorrowWeather)

Important Notes

Switch pattern matching on enums runs in constant time O(1).

Space used depends on enum size but is usually small.

Common mistake: forgetting to handle all enum cases in switch, which causes a compile error.

Use switch pattern matching when you want clear, safe, and readable code for enum values.

Summary

Enums group related values and can hold extra data.

Switch pattern matching checks enum cases and extracts data.

This makes your code safe and easy to understand.

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