@propertyWrapper declaration in Swift - Time & Space Complexity

Time Complexity: @propertyWrapper declaration

O(n)

Understanding Time Complexity

We want to understand how the time it takes to use a @propertyWrapper grows as we use it more in code.

Specifically, how does the cost change when we access or set wrapped properties many times?

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

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

struct Person {
  @Capitalized var name: String
}

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

This code defines a property wrapper that capitalizes strings when set, then uses it in a struct.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Capitalizing the string when setting the wrapped property.
• How many times: Each time the property is set, the capitalization runs once on the new string.

How Execution Grows With Input

Each time we set the property, the capitalization processes the whole string once.

Input Size (n)	Approx. Operations
10 (characters)	10 operations to capitalize
100 (characters)	100 operations to capitalize
1000 (characters)	1000 operations to capitalize

Pattern observation: The time grows linearly with the length of the string being set.

Final Time Complexity

Time Complexity: O(n)

This means the time to set the property grows in direct proportion to the string length.

Common Mistake

[X] Wrong: "Setting the property is always a quick, fixed-time action regardless of string size."

[OK] Correct: Because the wrapper modifies the string by capitalizing it, the time depends on how long the string is.

Interview Connect

Understanding how property wrappers affect performance helps you write clean code without surprises in speed as data grows.

Self-Check

"What if the property wrapper performed a more complex operation, like sorting an array, instead of capitalizing a string? How would the time complexity change?"

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