Why property wrappers reduce boilerplate in Swift - Challenge Your Understanding

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of a simple property wrapper usage

What is the output of this Swift code using a property wrapper?

Swift

import Foundation

@propertyWrapper
struct Capitalized {
    private var value: String = ""
    var wrappedValue: String {
        get { value }
        set { value = newValue.capitalized }
    }
}

struct Person {
    @Capitalized var name: String
}

var p = Person()
p.name = "john doe"
print(p.name)

A "john doe"

B "John Doe"

C "JOHN DOE"

D "john Doe"

💡 Hint

Think about what the property wrapper does when setting the value.

The property wrapper Capitalized changes the string to capitalized form when setting it. So "john doe" becomes "John Doe".

🧠 Conceptual

intermediate

Why do property wrappers reduce boilerplate?

Which of the following best explains why property wrappers reduce boilerplate code in Swift?

A They replace the need for classes and structs entirely.

B They automatically generate UI elements for properties without extra code.

C They allow you to write custom getter and setter logic once and reuse it across multiple properties.

D They make all properties immutable by default.

💡 Hint

Think about how property wrappers help avoid repeating code.

Property wrappers let you define common behavior for property access in one place, so you don't repeat the same getter/setter code for every property.

🔧 Debug

advanced

Identify the error in this property wrapper usage

What error will this Swift code produce?

Swift

@propertyWrapper
struct NonEmpty {
    var wrappedValue: String {
        didSet {
            if wrappedValue.isEmpty {
                wrappedValue = "Default"
            }
        }
    }
    init(wrappedValue: String) {
        self.wrappedValue = wrappedValue
        if wrappedValue.isEmpty {
            self.wrappedValue = "Default"
        }
    }
}

struct User {
    @NonEmpty var username: String
}

let u = User(username: "")

A Runtime error: infinite recursion in didSet

B Compile-time error: missing initial value for wrappedValue

C No error, username is set to "Default"

D Runtime error: nil value assigned to non-optional

💡 Hint

Check what happens when wrappedValue is set inside didSet.

Setting wrappedValue inside didSet triggers didSet again, causing infinite recursion and a runtime crash.

❓ Predict Output

advanced

Output of property wrapper with projected value

What will be printed by this Swift code?

Swift

@propertyWrapper
struct Logged<Value> {
    private var value: Value
    var wrappedValue: Value {
        get { value }
        set {
            print("Setting value to \(newValue)")
            value = newValue
        }
    }
    var projectedValue: String {
        "Value is currently \(value)"
    }
    init(wrappedValue: Value) {
        self.value = wrappedValue
    }
}

struct Config {
    @Logged var setting: Int = 10
}

var c = Config()
print(c.$setting)
c.setting = 20

A

Value is currently 10
Setting value to 20

B

Setting value to 10
Value is currently 10
Setting value to 20

C

Setting value to 10
Setting value to 20
Value is currently 20

D

Value is currently 20
Setting value to 20

💡 Hint

Remember when the setter print runs and what $property means.

The initial value is set in init without calling setter, so no print then. Printing c.$setting shows projectedValue. Setting c.setting to 20 triggers print in setter.

🧠 Conceptual

expert

How do property wrappers improve code maintainability?

Which statement best describes how property wrappers improve maintainability in Swift code?

A They replace the need for unit tests by ensuring property correctness.

B They automatically document properties with comments, reducing the need for manual documentation.

C They enforce strict type checking at compile time, preventing runtime errors.

D They centralize common property logic, making it easier to update behavior in one place rather than many.

💡 Hint

Think about how changing one property wrapper affects all properties using it.

By putting shared logic in a property wrapper, you only need to change that wrapper to update behavior everywhere it is used, improving maintainability.