> ## Documentation Index
> Fetch the complete documentation index at: https://docs.syntblaze.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Swift Mutating Method
A `mutating` method in Swift is an instance method defined within a value type (`struct` or `enum`) that explicitly permits the modification of its implicit `self` instance and its associated properties. By default, value types are immutable from within their own instance methods because Swift passes `self` as a constant (`let`).
Applying the `mutating` keyword alters the method's signature, instructing the compiler to treat `self` as an `inout` parameter.
## Underlying Mechanism
When a `mutating` method is invoked, Swift does not mutate the existing memory in place in the same way a reference type does. Instead, the following sequence occurs:
1. The existing `self` is passed into the method as an `inout` variable.
2. The method performs mutations on this local, mutable copy of `self`.
3. Upon the method's return, the modified copy completely overwrites the original instance in memory.
## Syntax and Implementation
```swift theme={"dark"}
struct StateContainer {
var count: Int
// Without 'mutating', the compiler throws:
// "Cannot assign to property: 'self' is immutable"
mutating func increment() {
self.count += 1
}
// Mutating methods can also reassign the entire 'self' instance
mutating func reset() {
self = StateContainer(count: 0)
}
}
```
## Architectural Rules and Constraints
* **Value Types Exclusive:** The `mutating` keyword is strictly reserved for value types (`struct`, `enum`, and protocols adopted by value types). Classes (`class`) are reference types; their properties can be modified without special keywords because `self` is a reference to a heap-allocated object, not a copied value.
* **Constant Instance Restriction:** A `mutating` method cannot be invoked on an instance assigned to a constant (`let`). Because the method requires write access to overwrite the original instance, the compiler enforces mutability at the call site.
```swift theme={"dark"}
var mutableContainer = StateContainer(count: 0)
mutableContainer.increment() // Allowed
let immutableContainer = StateContainer(count: 0)
immutableContainer.increment() // Compiler Error: Cannot use mutating member on immutable value: 'immutableContainer' is a 'let' constant
```
## Protocol Conformance
When defining a protocol that requires a method to modify the conforming instance, the method must be declared as `mutating` in the protocol definition.
```swift theme={"dark"}
protocol Resettable {
mutating func reset()
}
```
If a `class` conforms to this protocol, the `mutating` keyword is omitted in the class's implementation, as reference types do not require explicit mutation authorization. If a `struct` or `enum` conforms, the `mutating` keyword must be retained.
Tired of Poor Swift Skills? Fix That With Deep Grasping!
Learn More
