enum Methods / Properties / mutating

enum EnumName {
    case case1
    case case2

    // Computed property
    var propertyName: Type {
        switch self {
        case .case1: return value1
        case .case2: return value2
        }
    }

    // Method
    func methodName() {
        // Process
    }

    // Method that modifies self (mutating)
    mutating func mutatingMethod() {
        self = .case2
    }
}

// An enum with methods and properties
enum TrafficLight {
    case red, yellow, green

    // Computed property
    var waitSeconds: Int {
        switch self {
        case .red:    return 60
        case .yellow: return 5
        case .green:  return 45
        }
    }

    var canGo: Bool {
        return self == .green
    }

    // Instance method
    func description() -> String {
        switch self {
        case .red:    return "Stop"
        case .yellow: return "Caution"
        case .green:  return "Go"
        }
    }

    // mutating: advance to the next case
    mutating func next() {
        switch self {
        case .red:    self = .green
        case .green:  self = .yellow
        case .yellow: self = .red
        }
    }
}

var light = TrafficLight.red
print("\(light.description()) - Wait: \(light.waitSeconds)s")
print("Can go: \(light.canGo)")

light.next()
print("Next: \(light.description())")

light.next()
print("Next: \(light.description())")

By adding methods and properties to an enum, you can group all logic related to each case in one place. Encapsulating switch-case statements inside methods keeps the calling code simple and readable.

Because enums are value types, any method that modifies the enum's own case requires the mutating keyword. Computed properties are supported, but stored properties (such as var x: Int = 0) are not allowed inside an enum.

For the basics of enums, see enum basics / case / switch.