Composing property wrappers in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

Output of nested property wrappers

What is the output of the following Swift code using two composed property wrappers?

Swift

import Foundation

@propertyWrapper
struct Trimmed {
    private var value: String = ""
    var wrappedValue: String {
        get { value }
        set { value = newValue.trimmingCharacters(in: .whitespacesAndNewlines) }
    }
    init(wrappedValue: String) {
        self.wrappedValue = wrappedValue
    }
}

@propertyWrapper
struct Uppercased {
    private var value: String = ""
    var wrappedValue: String {
        get { value }
        set { value = newValue.uppercased() }
    }
    init(wrappedValue: String) {
        self.wrappedValue = wrappedValue
    }
}

struct User {
    @Trimmed @Uppercased var name: String
}

var user = User(name: "  swift  ")
print(user.name)

A "SWIFT"

B " SWIFT "

C "swift"

D "Swift"

💡 Hint

Remember the order in which property wrappers are applied matters.

The property wrappers are applied from the closest to the property outward. Here, @Uppercased is applied first, converting the string to uppercase, then @Trimmed trims whitespace. So the final output is "SWIFT".

❓ Predict Output

intermediate

Value of composed property wrappers with initial values

What will be the value of settings.title after this code runs?

Swift

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

@propertyWrapper
struct Suffix {
    private var value: String = ""
    private let suffix: String
    var wrappedValue: String {
        get { value }
        set { value = newValue + suffix }
    }
    init(wrappedValue: String, suffix: String) {
        self.suffix = suffix
        self.wrappedValue = wrappedValue
    }
}

struct Settings {
    @Suffix(suffix: "!") @Capitalized var title: String
}

var settings = Settings(title: "hello world")
print(settings.title)

A "Hello World!"

B "hello world!"

C "HELLO WORLD!"

D "Hello world!"

💡 Hint

Check the order of wrappers and how each modifies the string.

The @Capitalized wrapper capitalizes the string first, then @Suffix adds an exclamation mark. So the final value is "Hello World!".

🔧 Debug

advanced

Identify the error in composing property wrappers

What error does this Swift code produce when compiling?

Swift

@propertyWrapper
struct DoubleValue {
    var wrappedValue: Int {
        didSet { wrappedValue *= 2 }
    }
    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

@propertyWrapper
struct Increment {
    var wrappedValue: Int {
        get { value }
        set { value = newValue + 1 }
    }
    private var value: Int = 0
    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

struct Counter {
    @DoubleValue @Increment var count: Int
}

let c = Counter(count: 3)

A Error: Missing initializer for property 'value' in Increment

B Error: Recursive setter call causing infinite loop

C Error: Cannot apply two property wrappers to the same property

D No error, compiles successfully

💡 Hint

Look at the setter of DoubleValue and what happens when it sets wrappedValue.

The setter of DoubleValue modifies wrappedValue inside its own setter, causing infinite recursion and a compile-time error.

📝 Syntax

advanced

Which option correctly composes property wrappers with parameters?

Which of the following Swift code snippets correctly composes two property wrappers where one has a parameter?

A @Trimmed(suffix: "!") @Suffix var text: String = " hello "

B @Trimmed @Suffix(suffix: "!") var text: String = " hello "

C @Suffix @Trimmed(suffix: "!") var text: String = " hello "

D @Suffix(suffix: "!") @Trimmed var text: String = " hello "

💡 Hint

Remember how to apply parameters to property wrappers and their order.

Option D correctly applies @Suffix(suffix: "!") with a parameter and composes it with @Trimmed. Other options misuse parameters or order.

🚀 Application

expert

Number of times wrappedValue setter is called in composed wrappers

Given these two property wrappers and their composition, how many times is the wrappedValue setter called when setting example.value = 5?

Swift

@propertyWrapper
struct Logger {
    var wrappedValue: Int {
        didSet { print("Logger set to \(wrappedValue)") }
    }
    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

@propertyWrapper
struct Doubler {
    var wrappedValue: Int {
        get { value }
        set {
            value = newValue * 2
            print("Doubler set to \(value)")
        }
    }
    private var value: Int
    init(wrappedValue: Int) {
        self.value = wrappedValue * 2
        print("Doubler init with \(value)")
    }
}

struct Example {
    @Logger @Doubler var value: Int
}

var example = Example(value: 3)
example.value = 5

A 1 time

B 3 times

C 2 times

D 4 times

💡 Hint

Trace the setter calls from the outer wrapper to the inner wrapper.

Setting example.value = 5 calls the outer @Logger setter once, which sets the inner @Doubler wrappedValue once. So total setter calls are 2.