Swift Enums

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

var heading = Direction.north
heading = .west              // the type is known, so .west is enough

switch heading {
case .north: print("Up")
case .south: print("Down")
case .east, .west: print("Sideways")
}

• Enum names use UpperCamelCase; cases use lowerCamelCase.
• Once Swift knows the type, write cases with a leading dot: .west.
• A switch that covers every case needs no default, and the compiler warns if a case is missing.

Give every case a fixed raw value of type String, Int or another simple type:

enum Size: String, CaseIterable {
    case small = "S", medium = "M", large = "L"
}

Size.large.rawValue          // "L"
Size(rawValue: "M")          // Optional(Size.medium)
Size.allCases.count          // 3

• For String raw values you can leave the value out, and it defaults to the case name: case small has the raw value "small".
• Int raw values count up from 0 automatically.
• init(rawValue:) returns an optional, because the text might not match any case.
• Adopting CaseIterable provides allCases, a list of every case, which is handy for menus and pickers.

Each case can carry its own data, of different types:

enum DownloadState {
    case waiting
    case inProgress(percent: Int)
    case finished(fileURL: String)
    case failed(message: String)
}

let state = DownloadState.inProgress(percent: 40)
switch state {
case .waiting: print("Queued")
case .inProgress(let percent): print("\(percent)%")
case .finished(let url): print("Saved to \(url)")
case .failed(let message): print("Error: \(message)")
}

let inside the case pattern extracts the data. Associated values are the natural way to model states and results, where each outcome needs different information.

Enums can have computed properties and methods, often implemented with switch self:

enum Planet {
    case mercury, earth, mars
    var gravity: Double {
        switch self {
        case .mercury: 3.7
        case .earth: 9.8
        case .mars: 3.7
        }
    }
}

A method that changes self to another case must be mutating. In fact, Swift's own Optional is an enum with two cases, .some(value) and .none, which is why switch and if case work on optionals too.

You can compare simple enum cases with == straight away, because Swift makes enums without associated values Equatable automatically:

if heading == .north { print("Heading up") }

Once cases carry associated values, Swift can't assume how to compare them, so == stops working until you ask for it. Add Equatable to the declaration and Swift writes the comparison for you, as long as every associated value is Equatable too:

enum Status: Equatable {
    case loading
    case failed(String)
}
print(Status.failed("Offline") == .failed("Offline"))   // true

To check only which case a value is, ignoring its data, use pattern matching instead: if case .failed = status { ... } works with or without Equatable.

A common beginner design tracks a screen's state with separate flags:

var isLoading = false
var hasError = false
var items: [String] = []

Nothing stops isLoading and hasError both being true, a combination that makes no sense. An enum makes impossible states impossible to write:

enum LoadState {
    case idle
    case loading
    case loaded([String])
    case failed(String)
}
var state = LoadState.idle

The value is always exactly one case, and the data travels with the case that needs it: items only exist once loading has succeeded, and an error message only exists after a failure. A switch over state then forces every screen to handle each situation.