Kompozycja wielu wrapperów właściwości

Do jednej właściwości można zastosować wiele wrapperów właściwości. Kolejność ma znaczenie — zewnętrzne wrappery opakowują wewnętrzne — a kolejność inicjalizacji jest zgodna z kolejnością deklaracji.

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

Po zapisaniu `@A @B var x` następuje desugaring: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A opakowuje B, a B opakowuje 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 = " " } ```

Wrappery są inicjalizowane od najbardziej zewnętrznego do najbardziej wewnętrznego. Oznacza to, że inicjalizator zewnętrznego wrappera otrzymuje wynik transformacji wewnętrznego wrappera — a nie wartość pierwotną.

• Nie wszystkie wrappery można łatwo łączyć — należy sprawdzić, czy typy `wrappedValue` są zgodne • Kompilator Swift nie zawsze pozwala używać wielu wrapperów jednocześnie (zależy to od zgodności typów opakowywanych wartości) • Dostęp do `projectedValue` za pomocą `$x` obejmuje tylko projekcję najbardziej zewnętrznego wrappera

SwiftUI nie pozwala łączyć `@EnvironmentObject` i `@Published` dla tej samej właściwości, ale można obserwować modele `@EnvironmentObject`, które wewnętrznie używają `@Published`.

Użyj `_propertyName`, aby uzyskać bezpośredni dostęp do instancji wrappera: ```swift print(form._username) // A> — the outer wrapper instance ```

Często czytelniejszym rozwiązaniem jest umieszczenie logiki kompozycji wewnątrz pojedynczego wrappera: ```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 } } ```

Typowe poprawne zestawienia: • `@UserDefault` + `@Published` (trwałość danych + obserwacja) • `@NonNegative` + `@Clamped` (warstwy walidacji) • Specyficzne dla frameworka: `@Environment` + `@Binding` w widokach SwiftUI

Który z dwóch warstwowanych wrapperów jest inicjalizowany jako pierwszy?

Najważniejsze informacje: • `@A @B var x` zostaje rozwinięte do `A>` • Zewnętrzny wrapper jest inicjalizowany z `wrappedValue` wewnętrznego wrappera jako argumentem • `$x` zapewnia dostęp wyłącznie do `projectedValue` najbardziej zewnętrznego wrappera • `_x` zapewnia bezpośredni dostęp do instancji wrappera • Jeśli to możliwe, należy preferować jeden wrapper złożony zamiast głębokiego warstwowania Kurs ukończony! Następnie: typ Result.