Computed Property

A computed property is a property that does not allocate memory to store a value directly. Instead, it provides a custom getter and an optional setter to retrieve and mutate other properties and state indirectly. Because their values are evaluated dynamically at runtime, computed properties must always be declared as variables (var) and require an explicit type annotation.

Read-Write Computed Properties

A read-write computed property defines both a get block to calculate and return the value, and a set block to modify underlying state. The getter must include a return statement (or implicitly return a single expression) that matches the property’s declared type.

var explicitSetterProperty: Int {
    get {
        let calculatedValue = 42
        return calculatedValue
    }
    set(customName) {
        print("Updating state with \(customName)")
    }
}

If you do not explicitly define a parameter name for the setter, Swift automatically provides an implicit parameter named newValue.

var implicitSetterProperty: Int {
    get {
        return 42
    }
    set {
        print("Updating state with \(newValue)")
    }
}

Read-Only Computed Properties

If a computed property only defines a getter and omits the setter, it becomes a read-only computed property. Attempting to assign a value to a read-only computed property results in a compile-time error.

For read-only properties, Swift allows a shorthand syntax where the get keyword and its associated braces are omitted entirely.

var readOnlyProperty: String {
    return "Computed Value"
}

Mutating and Nonmutating Modifiers

When defining computed properties on value types (structures and enumerations), the getter is nonmutating and the setter is mutating by default. You can alter this behavior using the mutating and nonmutating modifiers:

• mutating get: Required if reading the property modifies the instance’s own state.
• nonmutating set: Used when the setter modifies external state (such as a reference type or global state) without modifying the value type instance itself.

struct AccessTracker {
    private var accessCount: Int = 0
    
    var trackedValue: Int {
        mutating get {
            accessCount += 1
            return accessCount
        }
    }
}

struct ExternalStateModifier {
    var proxyValue: Int {
        get { 
            return 0 
        }
        nonmutating set {
            print("Modifying external state with \(newValue) without mutating self")
        }
    }
}

Asynchronous and Throwing Computed Properties

Modern Swift allows read-only computed properties to participate in concurrency and error handling. A getter can be marked with async, throws, or both (async throws).

var asyncProperty: Int {
    get async {
        // Suspend and await an asynchronous operation
        return 100
    }
}

enum PropertyError: Error { case invalidState }

var throwingProperty: String {
    get throws {
        throw PropertyError.invalidState
    }
}

Technical Constraints and Characteristics

• No Backing Storage: Computed properties do not have an underlying instance variable. They act purely as an interface to compute or mutate other data.
• Immutability Restriction: You cannot declare a computed property with the let keyword. Even if the property is read-only, its value is not fixed at initialization, violating the contract of a constant.
• Type Inference: Swift cannot infer the type of a computed property from its getter’s return statement. The type annotation (e.g., : Int, : String) is strictly required.
• Supported Types: Computed properties can be declared within classes, structures, and enumerations. They are also heavily utilized in extensions to add computed state to existing types.
• Property Observers: You cannot attach property observers (willSet or didSet) to a newly defined computed property, as observation logic can simply be placed inside the set block. However, you can attach property observers to an inherited computed property by overriding it in a subclass.

Master Swift with Deep Grasping Methodology!

Learn More