Enum methods and computed properties in Swift - Deep Dive

Overview - Enum methods and computed properties

What is it?

Enums in Swift are types that group related values together. Enum methods are functions defined inside an enum to add behavior. Computed properties are special properties that calculate a value each time you access them instead of storing it. Together, they let enums do more than just hold values—they can also perform actions and provide dynamic information.

Why it matters

Without methods and computed properties, enums would only hold fixed values, limiting their usefulness. Adding these features lets you attach behavior and logic directly to enum cases, making your code cleaner and easier to understand. This helps you write safer and more organized programs, especially when handling different states or options.

Where it fits

Before learning this, you should understand basic Swift enums and properties. After this, you can explore advanced enum features like associated values, raw values, and protocol conformance. This knowledge also prepares you for designing complex data models and state machines.

Mental Model

Core Idea

Enums with methods and computed properties are like labeled boxes that not only store values but also know how to act and provide extra information about themselves.

Think of it like...

Imagine a vending machine with buttons (enum cases). Each button not only represents a snack but also knows its price (computed property) and can tell you if it's available (method). The buttons are simple, but with these extra features, they become smart helpers.

Enum Example
╔════════════════════════════╗
║        Enum: Snack         ║
╠════════════════════════════╣
║ Cases:                    ║
║  - chips                 ║
║  - chocolate             ║
║  - soda                  ║
╠════════════════════════════╣
║ Computed Property: price  ║
║ Method: isAvailable()     ║
╚════════════════════════════╝

Build-Up - 7 Steps

1

Foundation

Basic enum declaration in Swift

Concept: Learn how to define a simple enum with cases.

enum Direction { case north case south case east case west } // This enum groups four directions as named cases.

Result

You have a type Direction with four possible values: north, south, east, and west.

Understanding how to declare enums is the foundation for adding behavior like methods and computed properties.

2

Foundation

Introduction to computed properties

Concept: Learn what computed properties are and how to add them to types.

struct Rectangle { var width: Double var height: Double var area: Double { return width * height } } // area is a computed property that calculates the rectangle's area each time it's accessed.

Result

Accessing rectangle.area returns the product of width and height dynamically.

Computed properties let you create values that update automatically based on other data, without storing extra memory.

3

Intermediate

Adding methods to enums

🤔Before reading on: do you think enums can have functions that perform actions? Commit to yes or no.

Concept: Enums can have methods to add behavior related to their cases.

enum Direction { case north, south, east, west func description() -> String { switch self { case .north: return "Up" case .south: return "Down" case .east: return "Right" case .west: return "Left" } } } let dir = Direction.north print(dir.description()) // Output: Up

Result

Calling description() on an enum case returns a string describing it.

Knowing enums can have methods helps you bundle related logic directly with the enum, improving code clarity.

4

Intermediate

Computed properties inside enums

🤔Before reading on: do you think computed properties in enums can use switch statements? Commit to yes or no.

Concept: Enums can have computed properties that return values based on the current case.

enum Snack { case chips, chocolate, soda var price: Double { switch self { case .chips: return 1.5 case .chocolate: return 2.0 case .soda: return 1.0 } } } let snack = Snack.chocolate print(snack.price) // Output: 2.0

Result

Accessing snack.price returns the price for the specific snack case.

Computed properties in enums let you provide dynamic information tied to each case without extra storage.

5

Intermediate

Using methods and computed properties together

🤔Before reading on: can methods and computed properties in enums interact? Commit to yes or no.

Concept: Methods and computed properties can work together inside enums to provide rich behavior.

enum TrafficLight { case red, yellow, green var action: String { switch self { case .red: return "Stop" case .yellow: return "Caution" case .green: return "Go" } } func canGo() -> Bool { return self == .green } } let light = TrafficLight.yellow print(light.action) // Output: Caution print(light.canGo()) // Output: false

Result

You get both a descriptive string and a boolean decision from the enum instance.

Combining methods and computed properties lets enums represent both data and logic cleanly.

6

Advanced

Mutating methods in enums

🤔Before reading on: do you think enum methods can change the enum’s own case? Commit to yes or no.

Concept: Enums can have mutating methods that change their own case when called on a variable instance.

enum Switch { case on, off mutating func toggle() { switch self { case .on: self = .off case .off: self = .on } } } var lightSwitch = Switch.off lightSwitch.toggle() print(lightSwitch) // Output: off

Result

Calling toggle() changes the enum case from off to on.

Understanding mutating methods in enums unlocks state changes directly inside enum instances.

7

Expert

Computed properties with associated values

🤔Before reading on: can computed properties access associated values inside enum cases? Commit to yes or no.

Concept: Computed properties can extract and use associated values from enum cases to compute results dynamically.

enum Measurement { case weight(Double) case height(Double) var description: String { switch self { case .weight(let kg): return "Weight is \(kg) kg" case .height(let cm): return "Height is \(cm) cm" } } } let measure = Measurement.weight(70) print(measure.description) // Output: Weight is 70.0 kg

Result

The computed property returns a string using the associated value inside the enum case.

Knowing computed properties can access associated values lets you build flexible, descriptive enums that carry data and behavior.

Under the Hood

Swift enums are implemented as a type with a fixed set of possible values. When you add methods or computed properties, the compiler generates functions tied to the enum type. Computed properties run code each time you access them, often using switch statements to check the current case. Mutating methods can change the enum's stored case because enums are value types, and marking methods as mutating allows modification of self.

Why designed this way?

Swift was designed to make enums more powerful and expressive than simple lists of values. Adding methods and computed properties lets enums encapsulate both data and behavior, following modern programming principles. This design avoids the need for separate helper functions and keeps related logic close to the data it operates on, improving safety and readability.

Enum with Methods and Computed Properties
╔════════════════════════════════════╗
║ Enum Type: TrafficLight            ║
╠════════════════════════════════════╣
║ Cases: red, yellow, green          ║
║                                    ║
║ Computed Property: action          ║
║   └─ runs switch on self           ║
║   └─ returns String                ║
║                                    ║
║ Method: canGo()                    ║
║   └─ checks if self == .green     ║
║   └─ returns Bool                  ║
╚════════════════════════════════════╝

Myth Busters - 4 Common Misconceptions

Quick: Can enum computed properties store values like regular properties? Commit to yes or no.

Common Belief: Computed properties in enums store values just like regular stored properties.

Reality: Computed properties do not store values; they calculate and return a value each time they are accessed.

Why it matters: Assuming computed properties store values can lead to unexpected behavior and bugs when the value depends on other data or changes over time.

Quick: Can enum methods modify the enum case without being marked mutating? Commit to yes or no.

Common Belief: Enum methods can change the enum’s case freely without special keywords.

Reality: Only methods marked as mutating can change the enum’s case because enums are value types.

Why it matters: Not marking methods as mutating when they modify self causes compiler errors and confusion about how enums behave.

Quick: Do all enum cases share the same computed property value? Commit to yes or no.

Common Belief: Computed properties return the same value regardless of the enum case.

Reality: Computed properties usually return different values depending on the current enum case, often using switch statements.

Why it matters: Thinking computed properties are static can cause misuse and limit the power of enums to represent varied data.

Quick: Can computed properties in enums access associated values? Commit to yes or no.

Common Belief: Computed properties cannot use associated values inside enum cases.

Reality: Computed properties can access and use associated values via pattern matching in switch statements.

Why it matters: Missing this limits the ability to write expressive enums that combine data and behavior.

Expert Zone

1

Computed properties in enums are recomputed every time they are accessed, so avoid expensive calculations inside them without caching.

2

Mutating methods on enums change the entire enum value, not just parts, because enums are value types, which can affect performance if used heavily.

3

Enums with methods and computed properties can conform to protocols, enabling polymorphism and more flexible designs.

When NOT to use

Avoid adding complex logic or heavy computations inside enum computed properties or methods if performance is critical; consider using structs or classes instead. Also, if you need mutable state beyond changing the enum case, enums may not be the best choice.

Production Patterns

In real-world Swift apps, enums with methods and computed properties are used to model state machines, represent API response types with behavior, and encapsulate UI states with descriptive logic. For example, an enum representing app themes might have computed properties for colors and methods to apply styles.

Connections

Object-Oriented Programming (OOP) Methods

Enums with methods are similar to classes having functions that operate on their data.

Understanding enum methods helps bridge the gap between simple data containers and full objects with behavior, showing how Swift blends functional and OOP styles.

Functional Programming Pattern Matching

Computed properties in enums often use switch statements, a form of pattern matching common in functional languages.

Recognizing this connection helps learners appreciate how Swift enums combine functional patterns with imperative code.

State Machines in Systems Engineering

Enums with methods and computed properties model states and transitions, like state machines used in engineering.

Seeing enums as state machines clarifies their role in managing complex workflows and system states in software.

Common Pitfalls

#1 Trying to store a value in a computed property inside an enum.

Wrong approach:

enum Example {
var storedValue: Int = 5 // Error: Computed properties cannot store values
}

Correct approach:

enum Example {
var computedValue: Int {
return 5
}
}

Root cause:

Confusing computed properties with stored properties; computed properties only calculate and return values.

#2 Modifying enum case inside a method without marking it mutating.

Wrong approach:

enum Light {
case on, off
func toggle() {
self = (self == .on) ? .off : .on // Error: Cannot assign to self in non-mutating method
}
}

Correct approach:

enum Light {
case on, off
mutating func toggle() {
self = (self == .on) ? .off : .on
}
}

Root cause:

Not understanding that value types require mutating keyword to change self inside methods.

#3 Assuming computed properties return the same value for all enum cases.

Wrong approach:

enum Color {
case red, green, blue
var hex: String {
return "#FFFFFF" // Incorrect: same value for all cases
}
}

Correct approach:

enum Color {
case red, green, blue
var hex: String {
switch self {
case .red: return "#FF0000"
case .green: return "#00FF00"
case .blue: return "#0000FF"
}
}
}

Root cause:

Not using switch or pattern matching to differentiate behavior per enum case.

Key Takeaways

Swift enums can have methods and computed properties that add behavior and dynamic information to each case.

Computed properties calculate values on demand and do not store data, making enums more flexible and expressive.

Mutating methods allow enums to change their own case, enabling state changes within value types.

Using switch statements inside methods and computed properties lets you customize behavior for each enum case.

Combining these features helps you write safer, clearer, and more organized code by bundling data and logic together.