Composición de varios property wrappers

Se pueden aplicar varios property wrappers a una sola propiedad. El orden es importante: los wrappers externos envuelven a los internos y el orden de inicialización sigue el orden de declaración.

```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 } ```

Cuando escribe `@A @B var x`, la desazucaración es: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A envuelve a B, que a su vez envuelve a 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 = " " } ```

Los wrappers se inicializan desde el más externo hasta el más interno. Esto significa que el init del wrapper externo recibe el resultado de la transformación del wrapper interno, no el valor original.

• No todos los wrappers se combinan correctamente; compruebe que los tipos de `wrappedValue` coincidan • Es posible que el compilador de Swift no permita siempre varios wrappers; depende de la compatibilidad de los tipos envueltos • El acceso a `projectedValue` mediante `$x` solo llega a la proyección del wrapper más externo

SwiftUI no permite encadenar `@EnvironmentObject` y `@Published` en la misma propiedad, pero puede observar modelos `@EnvironmentObject` que usan `@Published` internamente.

Use `_propertyName` para acceder directamente a la instancia del wrapper: ```swift print(form._username) // A> — the outer wrapper instance ```

A menudo resulta más sencillo combinar la lógica dentro de un único 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 } } ```

Pila de wrappers válidas habituales: • `@UserDefault` + `@Published` (persistencia de datos y observación) • `@NonNegative` + `@Clamped` (capas de validación) • Específico del framework: `@Environment` + `@Binding` en vistas de SwiftUI

Cuando se encadenan dos property wrappers, ¿cuál se inicializa primero?

Puntos clave: • `@A @B var x` se desazucara como `A>` • El wrapper externo se inicializa usando como entrada el `wrappedValue` del interno • `$x` solo llega al `projectedValue` más externo • `_x` permite acceder directamente a la instancia del wrapper • Cuando sea posible, prefiera un único wrapper combinado a un encadenamiento profundo ¡Curso completado! Siguiente tema: el tipo Result.