Comporre più property wrapper

È possibile applicare più property wrapper a una singola proprietà. L'ordine è importante: i wrapper esterni avvolgono quelli interni e l'ordine di inizializzazione segue l'ordine delle dichiarazioni.

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

Quando scrive `@A @B var x`, la trasformazione equivalente è: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A avvolge B, che a sua volta avvolge 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 = " " } ```

I wrapper vengono inizializzati dall'esterno verso l'interno. Ciò significa che l'inizializzatore del wrapper esterno riceve il risultato della trasformazione del wrapper interno, non il valore originale.

• Non tutti i wrapper possono essere composti senza problemi: verifichi che i tipi di `wrappedValue` corrispondano • Il compilatore Swift potrebbe non consentire sempre più wrapper (dipende dalla compatibilità dei tipi wrapped) • L'accesso a `projectedValue` tramite `$x` raggiunge solo la proiezione del wrapper più esterno

SwiftUI non consente di annidare `@EnvironmentObject` e `@Published` nella stessa proprietà, ma è possibile osservare modelli `@EnvironmentObject` che usano internamente `@Published`.

Utilizzi `_propertyName` per accedere direttamente all'istanza del wrapper: ```swift print(form._username) // A> — the outer wrapper instance ```

Spesso è più pulito comporre la logica all'interno di un unico 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 } } ```

Combinazioni comuni valide: • `@UserDefault` + `@Published` (persistenza dei dati + osservazione) • `@NonNegative` + `@Clamped` (livelli di convalida) • Specifico dei framework: `@Environment` + `@Binding` nelle viste SwiftUI

Quando due property wrapper sono annidati, quale viene inizializzato per primo?

Punti chiave: • `@A @B var x` viene trasformato in `A>` • Il wrapper esterno viene inizializzato usando il `wrappedValue` del wrapper interno come input • `$x` raggiunge solo il `projectedValue` più esterno • `_x` consente di accedere direttamente all'istanza del wrapper • Quando possibile, preferisca un unico wrapper composto a un annidamento profondo Corso completato! Prossimo argomento: Result.