Composição de vários wrappers de propriedade

Vários invólucros de propriedades podem ser aplicados a uma única propriedade. A ordem importa — os invólucros externos envolvem os internos — e a ordem de inicialização segue a ordem das declarações.

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

Ao escrever `@A @B var x`, a expansão sintática é: ```swift var _x: A> = A(wrappedValue: B(wrappedValue: 0)) ``` A encapsula B, que encapsula 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 = " " } ```

Os encapsuladores são inicializados do mais externo para o mais interno. Isso significa que o inicializador do encapsulador externo recebe o resultado da transformação do encapsulador interno, e não o valor original.

• Nem todos os encapsuladores podem ser compostos corretamente — verifique se os tipos de `wrappedValue` correspondem • O compilador do Swift talvez não permita vários encapsuladores em todos os casos (isso depende da compatibilidade dos tipos encapsulados) • O acesso a `projectedValue` por meio de `$x` alcança apenas a projeção do encapsulador mais externo

O SwiftUI não permite empilhar `@EnvironmentObject` e `@Published` na mesma propriedade, mas você pode observar modelos `@EnvironmentObject` que usam `@Published` internamente.

Use `_propertyName` para acessar diretamente a instância do encapsulador: ```swift print(form._username) // A> — the outer wrapper instance ```

Muitas vezes, é mais simples compor a lógica dentro de um único encapsulador: ```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 } } ```

Empilhamentos válidos comuns: • `@UserDefault` + `@Published` (persistência de dados + observação) • `@NonNegative` + `@Clamped` (camadas de validação) • Específico do framework: `@Environment` + `@Binding` em visualizações do SwiftUI

Quando dois encapsuladores de propriedades são empilhados, qual é inicializado primeiro?

Principais conclusões: • `@A @B var x` é expandido sintaticamente para `A>` • O encapsulador externo é inicializado usando o `wrappedValue` do interno como entrada • `$x` alcança apenas o `projectedValue` mais externo • `_x` acessa diretamente a instância do encapsulador • Prefira um único encapsulador composto a um empilhamento profundo quando possível Curso concluído! Próximo: tipo de resultado.