Composing Multiple Property Wrappers

Multiple property wrappers can be applied to a single property. The order matters — outer wrappers wrap inner ones — and initialization order follows declaration order.

```swift @propertyWrapper struct A { var wrappedValue: Int { didSet { print("A") } } init(wrappedValue: Int) { self.wrappedValue = wrappedValue } } @propertyWrapper struct B { var wrappedValue: Int { didSet { print("B") } } init(wrappedValue: Int) { self.wrappedValue = wrappedValue } } struct S { @A @B var x = 0 } ```

When you write `@A @B var x`, the desugaring is: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A wraps B which wraps Int.

```swift @propertyWrapper struct Trimmed { var wrappedValue: String { didSet { wrappedValue = wrappedValue.trimmingCharacters(in:.whitespaces) } } init(wrappedValue: String) { self.wrappedValue = wrappedValue.trimmingCharacters(in:.whitespaces) } } @propertyWrapper struct NonEmpty { var wrappedValue: String { didSet { if wrappedValue.isEmpty { wrappedValue = "(empty)" } } } init(wrappedValue: String) { self.wrappedValue = wrappedValue.isEmpty ? "(empty)" : wrappedValue } } struct Form { @NonEmpty @Trimmed var username = " " } ```

Wrappers are initialised from outermost to innermost. This means the outer wrapper's init receives the result of the inner wrapper's transformation — not the original value.

• Not all wrappers compose cleanly — check `wrappedValue` types match • Swift compiler may not always allow multiple wrappers (depends on wrapped type compatibility) • projectedValue access `$x` only reaches the outermost wrapper's projection

SwiftUI doesn't allow stacking `@EnvironmentObject` and `@Published` on the same property, but you can observe `@EnvironmentObject` models that use `@Published` internally.

Use `_propertyName` to directly access the wrapper instance: ```swift print(form._username) // A> — the outer wrapper instance ```

Often it's cleaner to compose logic inside a single wrapper: ```swift @propertyWrapper struct CleanUsername { var wrappedValue: String { didSet { wrappedValue = clean(wrappedValue) } } func clean(_ s: String) -> String { let t = s.trimmingCharacters(in:.whitespaces) return t.isEmpty ? "(empty)" : t } } ```

Common valid stacks: • `@UserDefault` + `@Published` (data persistence + observation) • `@NonNegative` + `@Clamped` (validation layers) • Framework-specific: `@Environment` + `@Binding` in SwiftUI views

When two property wrappers are stacked, which initialises first?

Key takeaways: • `@A @B var x` desugars to `A>` • Outer initialises with inner's wrappedValue as input • `$x` reaches outermost projectedValue only • `_x` accesses the wrapper instance directly • Prefer single composed wrapper over deep stacking when possible Course complete! Next: Result type.