Mutating Methods

struct TypeName {
    var property: Type

    mutating func methodName() {
        property = newValue
    }
}

var instance = TypeName(property: value)   // must be var
instance.methodName()

// Define a struct `Counter`
struct Counter {
    // Declare a mutable variable `count`, initialized to `0`
    var count = 0
    mutating func increment() {
        count += 1
    }
}
// Declare a mutable variable `counter`, initialized to `Counter()`
var counter = Counter()
counter.increment()
counter.increment()
// Print "Count: \(counter.count)" to the console
print("Count: \(counter.count)")

// Define a struct `Switch`
struct Switch {
    // Declare a mutable variable `isOn`, initialized to `false`
    var isOn = false
    mutating func toggle() {
        isOn.toggle()
    }
}
// Declare a mutable variable `lightSwitch`, initialized to `Switch()`
var lightSwitch = Switch()
lightSwitch.toggle()
// Print "Is on: \(lightSwitch.isOn)" to the console
print("Is on: \(lightSwitch.isOn)")

Methods · Methods in Enums · Initializers · Property Observers

1. Forgetting the mutating keyword on a struct method that modifies self or any of its properties, causing a compile error.
2. Trying to call a mutating method on a struct instance declared with let; only var instances allow mutation.
3. Adding mutating to a class method by mistake; the keyword is only meaningful for structs and enums, not classes.

• Struct methods that modify properties must be marked mutating before func.
• A mutating method can only be called on an instance stored in a var, not a let.
• Classes never need mutating since their methods can always change properties.
• A mutating method can even reassign self entirely to a new instance of the same struct.