@propertyWrapper declaration in Swift - Step-by-Step Execution

Concept Flow - @propertyWrapper declaration

Define @propertyWrapper struct

↓

Add wrappedValue property

↓

Use @propertyWrapper on variable

↓

Access variable

↓

wrappedValue getter/setter runs

↓

Variable value updated or retrieved

This flow shows how a @propertyWrapper is declared, then used on a variable, and how accessing that variable runs the wrapper's getter and setter.

Execution Sample

Swift

import SwiftUI
@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)

This code defines a @propertyWrapper that capitalizes a string, uses it on a variable, sets a lowercase name, and prints the capitalized result.

Execution Table

Step	Action	Variable/Property	Value Before	Value After	Output
1	Define @propertyWrapper struct Capitalized	-	-	-	-
2	Create Person instance p	p	-	-	-
3	Set p.name = "john doe"	p.name (wrappedValue setter)	""	"John Doe"	-
4	Get p.name for print	p.name (wrappedValue getter)	"John Doe"	"John Doe"	"John Doe"
5	Print output	-	-	-	John Doe

💡 All steps complete, program ends after printing capitalized name.

Variable Tracker

Variable	Start	After Step 3	After Step 4	Final
p.name (wrappedValue)	""	"John Doe"	"John Doe"	"John Doe"
p._name.value (private storage)	""	"John Doe"	"John Doe"	"John Doe"

Key Moments - 2 Insights

Why does setting p.name to "john doe" store "John Doe" instead?

Because the wrappedValue setter capitalizes the newValue before storing it, as shown in execution_table step 3.

What happens when we access p.name to print it?

The wrappedValue getter returns the stored capitalized string without change, as shown in execution_table step 4.

Visual Quiz - 3 Questions

Look at the execution_table step 3, what is the value stored after setting p.name?

A "john doe"

B "John Doe"

C "JOHN DOE"

D "john Doe"

💡 Hint

Check the 'Value After' column in step 3 of execution_table.

At which step does the wrappedValue getter run?

A Step 4

B Step 2

C Step 3

D Step 5

💡 Hint

Look for 'wrappedValue getter' in the Action column of execution_table.

If we remove the capitalization in the setter, what would p.name print?

A "JOHN DOE"

B "John Doe"

C "john doe"

D "john Doe"

💡 Hint

Consider how the setter changes the value before storing it, see execution_table step 3.

Concept Snapshot

@propertyWrapper declaration syntax:
@propertyWrapper struct WrapperName {
  var wrappedValue: Type { get set }
}

Use by prefixing variable with @WrapperName.
Accessing variable calls wrappedValue getter/setter.
Allows custom behavior on property access.

Full Transcript

This visual trace shows how a Swift @propertyWrapper is declared and used. First, the wrapper struct Capitalized is defined with a wrappedValue property that capitalizes any new value set. Then, a Person struct uses @Capitalized on its name property. When we create a Person instance and set p.name to "john doe", the setter capitalizes it to "John Doe" before storing. When we print p.name, the getter returns the stored capitalized string. The execution table tracks each step, showing how the wrappedValue getter and setter run and how the value changes. Key moments clarify why the value is capitalized and how access works. The quiz tests understanding of these steps. The snapshot summarizes the syntax and behavior of @propertyWrapper declarations.

Practice

1. What is the main purpose of using @propertyWrapper in Swift?

easy

A. To define functions that run asynchronously

B. To create new data types like classes or structs

C. To add reusable behavior to variables by controlling their access and storage

D. To handle errors in Swift code

Solution

1. Step 1: Understand what @propertyWrapper does

   @propertyWrapper is used to add reusable behavior to variables, such as validation or transformation, by controlling how their values are stored and accessed.

2. Step 2: Compare with other options

   Options B, C, and D describe unrelated Swift features: defining types, async functions, and error handling, which are not the purpose of @propertyWrapper.

3. Final Answer:

   To add reusable behavior to variables by controlling their access and storage -> Option C

4. Quick Check:

   @propertyWrapper purpose = reusable variable behavior [OK]

Hint: Remember: @propertyWrapper controls variable behavior [OK]

Common Mistakes:

• Confusing @propertyWrapper with class or struct definitions
• Thinking it handles async code or errors
• Believing it creates new data types

2. Which of the following is the correct minimal syntax to declare a property wrapper named Capitalized?

easy

A. @propertyWrapper struct Capitalized { var wrappedValue: String }

B. struct Capitalized { @propertyWrapper var wrappedValue: String }

C. struct Capitalized { var wrappedValue: String }

D. @propertyWrapper var Capitalized: String

Solution

1. Step 1: Recall the syntax for declaring a property wrapper

   A property wrapper must be declared as a struct or class with the @propertyWrapper attribute before its definition, and it must have a wrappedValue property.

2. Step 2: Analyze each option

   struct Capitalized { var wrappedValue: String } misses the @propertyWrapper attribute. @propertyWrapper struct Capitalized { var wrappedValue: String } correctly uses @propertyWrapper before the struct and defines wrappedValue. struct Capitalized { @propertyWrapper var wrappedValue: String } incorrectly places @propertyWrapper before the property, which is invalid. @propertyWrapper var Capitalized: String tries to declare a variable with @propertyWrapper, which is incorrect syntax.

3. Final Answer:

   @propertyWrapper struct Capitalized { var wrappedValue: String } -> Option A

4. Quick Check:

   Property wrapper syntax = @propertyWrapper before struct [OK]

Hint: Put @propertyWrapper before struct/class, not before property [OK]

Common Mistakes:

• Placing @propertyWrapper before the property instead of the struct
• Omitting the @propertyWrapper attribute
• Trying to declare property wrapper as a variable

3. Given the code below, what will be printed?

 @propertyWrapper
 struct Trimmed {
     var wrappedValue: String
     init(wrappedValue: String) {
         self.wrappedValue = wrappedValue.trimmingCharacters(in: .whitespaces)
     }
 }

 struct User {
     @Trimmed var name: String
 }

 let user = User(name: "  Alice  ")
 print(user.name)

medium

A. "Alice"

B. " Alice "

C. Compilation error

D. "Alice "

Solution

1. Step 1: Understand the property wrapper behavior

   The Trimmed wrapper trims whitespace from the string when initialized in its init. So the initial value " Alice " is trimmed to "Alice".

2. Step 2: Check the printed value

   The user.name accesses the wrapped value, which is trimmed. So printing user.name outputs "Alice" without spaces.

3. Final Answer:

   "Alice" -> Option A

4. Quick Check:

   Trimmed wrapper removes spaces = "Alice" [OK]

Hint: Property wrapper trims on init, so output is trimmed [OK]

Common Mistakes:

• Assuming original spaces remain
• Thinking didSet runs before init
• Overlooking the trimming in init

4. Identify the error in the following property wrapper declaration:

 @propertyWrapper
 struct Positive {
     var wrappedValue: Int
     init(wrappedValue: Int) {
         if wrappedValue < 0 {
             wrappedValue = 0
         }
         self.wrappedValue = wrappedValue
     }
 }

medium

A. No error, code is correct

B. Missing @propertyWrapper attribute

C. wrappedValue property must be a computed property

D. Cannot assign to parameter 'wrappedValue' inside init

Solution

1. Step 1: Analyze the init parameter usage

   In Swift, function parameters are constants and cannot be assigned new values. The line wrappedValue = 0 inside the init tries to assign to the parameter, which causes an error.

2. Step 2: Check other options

   The @propertyWrapper attribute is present, so B is wrong. The wrappedValue can be stored or computed, so C is wrong. The code has an error, so A is wrong.

3. Final Answer:

   Cannot assign to parameter 'wrappedValue' inside init -> Option D

4. Quick Check:

   Function parameters are constants = assignment error [OK]

Hint: Don't assign to init parameters; use a local var instead [OK]

Common Mistakes:

• Trying to assign directly to init parameters
• Thinking wrappedValue must be computed
• Ignoring the @propertyWrapper attribute

5. You want to create a property wrapper Clamped that limits an Int value between a minimum and maximum. Which of the following is the correct way to declare it so that you can use it like @Clamped(min: 0, max: 10) var score: Int?

hard

A. @propertyWrapper struct Clamped {
var wrappedValue: Int
init(min: Int, max: Int) {
wrappedValue = 0
}
}

B. @propertyWrapper struct Clamped {
private var value: Int
let min: Int
let max: Int
var wrappedValue: Int {
get { value }
set { value = min(max(newValue, min), max) }
}
init(wrappedValue: Int, min: Int, max: Int) {
self.min = min
self.max = max
self.value = min(max(wrappedValue, min), max)
}
}

C. @propertyWrapper struct Clamped {
var wrappedValue: Int
init(wrappedValue: Int) {
wrappedValue = 0
}
}

D. @propertyWrapper struct Clamped {
var wrappedValue: Int {
didSet {
if wrappedValue < min { wrappedValue = min }
if wrappedValue > max { wrappedValue = max }
}
}
let min: Int
let max: Int
}

Solution

1. Step 1: Understand the requirements for Clamped

   The wrapper must accept min and max parameters, clamp the wrappedValue between them, and allow usage with @Clamped(min: 0, max: 10).

2. Step 2: Analyze each option

   @propertyWrapper struct Clamped { private var value: Int let min: Int let max: Int var wrappedValue: Int { get { value } set { value = min(max(newValue, min), max) } } init(wrappedValue: Int, min: Int, max: Int) { self.min = min self.max = max self.value = min(max(wrappedValue, min), max) } } correctly defines min and max as let constants, stores the value privately, clamps in init and setter, and has the correct init signature. @propertyWrapper struct Clamped { var wrappedValue: Int init(min: Int, max: Int) { wrappedValue = 0 } } lacks wrappedValue initialization and clamping logic. @propertyWrapper struct Clamped { var wrappedValue: Int init(wrappedValue: Int) { wrappedValue = 0 } } does not accept min and max parameters. @propertyWrapper struct Clamped { var wrappedValue: Int { didSet { if wrappedValue < min { wrappedValue = min } if wrappedValue > max { wrappedValue = max } } } let min: Int let max: Int } tries to clamp in didSet but does not initialize wrappedValue properly and does not clamp in init, which can cause invalid initial values.

3. Final Answer:

   @propertyWrapper struct Clamped { private var value: Int let min: Int let max: Int var wrappedValue: Int { get { value } set { value = min(max(newValue, min), max) } } init(wrappedValue: Int, min: Int, max: Int) { self.min = min self.max = max self.value = min(max(wrappedValue, min), max) } } -> Option B

4. Quick Check:

   Clamped wrapper needs init with min/max and clamping in setter [OK]

Hint: Use init with wrappedValue and params; clamp in setter and init [OK]

Common Mistakes:

• Not accepting min and max in init
• Not clamping value on initialization
• Trying to clamp only in didSet without proper init