@propertyWrapper declaration in Swift - Practice Problems & Coding Challenges

Challenge - 5 Problems

❓ Predict Output

intermediate

What is the output of this Swift code using @propertyWrapper?

Consider the following Swift code that uses a property wrapper. What will be printed when running this code?

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

Look at how the setter modifies the string using the capitalized property.

The @propertyWrapper Capitalized modifies the string when it is set by capitalizing it. So when "john doe" is assigned, it becomes "John Doe".

❓ Predict Output

intermediate

What error does this Swift @propertyWrapper code produce?

Examine this Swift code using @propertyWrapper. What error will it produce when compiled?

Swift

@propertyWrapper
struct NumberWrapper {
    var wrappedValue: Int

    init() {
        wrappedValue = 0
    }
}

struct Data {
    @NumberWrapper var number: Int
}

let d = Data()

A Error: Cannot assign to property: 'wrappedValue' is a get-only property

B Error: Property wrapper must have an initial value

C No error, compiles successfully

D Error: Missing argument for parameter 'wrappedValue' in call

💡 Hint

Check how the property wrapper is initialized and what initializers are available.

The property wrapper NumberWrapper has an init() without parameters, but the compiler expects an init(wrappedValue:) initializer to initialize the wrapped property. Since it is missing, the compiler complains about missing argument for wrappedValue.

🔧 Debug

advanced

Why does this @propertyWrapper code cause a runtime crash?

This Swift code compiles but crashes at runtime. What is the cause of the crash?

Swift

@propertyWrapper
struct Positive {
    private var value: Int
    var wrappedValue: Int {
        get { value }
        set {
            guard newValue > 0 else {
                fatalError("Value must be positive")
            }
            value = newValue
        }
    }

    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

struct Account {
    @Positive var balance: Int
}

let a = Account(balance: -10)

A The code crashes because value is not initialized before use

B The fatalError is triggered because the initial wrappedValue is negative

C The code crashes due to infinite recursion in the setter

D No crash occurs; the code runs fine

💡 Hint

Look at how the initial wrappedValue is assigned and how the setter guard works.

The Account(balance: -10) calls Positive.init(wrappedValue: -10), which assigns self.wrappedValue = -10. This invokes the setter of wrappedValue. The guard in the setter checks if newValue > 0, which fails, triggering fatalError("Value must be positive").

📝 Syntax

advanced

Which option correctly declares a @propertyWrapper with projectedValue?

Choose the correct Swift code that declares a @propertyWrapper with a projectedValue property.

A

@propertyWrapper
struct Wrapper {
    var wrappedValue: Int
    var projectedValue: String {
        "Value is \(wrappedValue)"
    }
}

B

@propertyWrapper
struct Wrapper {
    var wrappedValue: Int
    var projectedValue: Int {
        wrappedValue * 2
    }
}

C

@propertyWrapper
struct Wrapper {
    var wrappedValue: Int
    var projectedValue: Int {
        get { wrappedValue * 2 }
    }
}

D

@propertyWrapper
struct Wrapper {
    var wrappedValue: Int
    var projectedValue: Int {
        set { wrappedValue = newValue }
    }
}

💡 Hint

The projectedValue must be a readable property, usually with a getter.

Option C correctly declares projectedValue with a getter that returns wrappedValue * 2. Option C returns a String but does not specify a getter explicitly (which is allowed but less common). Option C uses valid shorthand syntax for a read-only computed property. Option C declares only a setter without a getter, which is invalid.

🚀 Application

expert

How many items are in the resulting array after using this @propertyWrapper in a loop?

Given this Swift code using a @propertyWrapper that tracks assignments, how many elements will be in the assignments array after the loop?

Swift

@propertyWrapper
class Tracker {
    private(set) var assignments: [Int] = []
    var wrappedValue: Int {
        didSet {
            assignments.append(wrappedValue)
        }
    }
    init(wrappedValue: Int) {
        self.wrappedValue = wrappedValue
    }
}

struct Data {
    @Tracker var value: Int
}

var data = Data(value: 0)
for i in 1...3 {
    data.value = i
}

let count = data.$value.assignments.count
print(count)

A 4

B 3

C 1

D 0

💡 Hint

Remember the initial assignment in init and the didSet calls in the loop.

The assignments array starts with the initial wrappedValue 0 added in init (via didSet). Then each assignment in the loop (1, 2, 3) triggers didSet appending the new value. So total 4 elements are appended.