Como os Wrappers de Propriedade e Observadores Facilitam o Desenvolvimento em Swift

O uso de wrappers de propriedade e observadores em Swift representa uma das abordagens mais poderosas e eficientes para criar código modular e de fácil manutenção. Esses conceitos permitem que os desenvolvedores automatizem a resposta a mudanças de valores em propriedades, sem a necessidade de um gerenciamento manual extenso. A seguir, veremos como esses mecanismos funcionam e como eles podem ser aplicados para melhorar a qualidade e a escalabilidade do código.

Quando lidamos com propriedades em Swift, muitas vezes precisamos realizar ações específicas sempre que o valor de uma propriedade muda. Por exemplo, pode ser necessário atualizar a interface do usuário, validar dados ou executar outras tarefas sempre que uma propriedade for modificada. Com os observadores de propriedade, podemos capturar essas mudanças de forma automática. Swift oferece dois tipos principais de observadores: willSet e didSet. Esses métodos permitem que o código seja executado antes e depois de uma mudança de valor, respectivamente.

swift
Copy code
struct Item {
    var quantidade: Int {
        willSet {
            print("A quantidade está prestes a ser alterada para \(newValue)")
        }
        didSet {
            if quantidade > 100 {
                print("Aviso: Quantidade excessiva!")
            }
        }
    }
    init(quantidade: Int) {
        self.quantidade = quantidade
    }
}

Este exemplo ilustra como os observadores willSet e didSet são utilizados para monitorar as mudanças na propriedade quantidade. Quando o valor da propriedade é alterado, o código dentro de willSet é executado antes da mudança, e o código dentro de didSet é executado logo após. Assim, é possível implementar lógica de validação ou outras ações em resposta às alterações.

Wrappers de Propriedade

Por exemplo, se quisermos formatar uma data sempre que ela for acessada, podemos usar um wrapper de propriedade para encapsular a lógica de formatação. Suponha que temos uma propriedade dataDeNascimento em um tipo Pessoa e desejamos exibir essa data de forma simplificada, apenas com o formato de dia, mês e ano. Podemos definir um wrapper de propriedade assim:

swift
Copy code
@propertyWrapper

struct FormatarData {
    var valorOriginal: Date
    var wrappedValue: Date {
        get { valorOriginal }
        set { valorOriginal = newValue }
    }
    var projectedValue: String {
        let formatador = DateFormatter()
        formatador.dateFormat = "yyyy-MM-dd"
        return formatador.string(from: valorOriginal)
    }
}

Ao usar o @FormatarData como um wrapper para a propriedade dataDeNascimento da Pessoa, agora podemos acessar tanto o valor original quanto a versão formatada da data, facilitando a apresentação dessa informação sem alterar o valor subjacente:

swift
Copy code
struct Pessoa {

    var nome: String
    @FormatarData var dataDeNascimento: Date
}
let pessoa = Pessoa(nome: "Jon", dataDeNascimento: Date())
print(pessoa.dataDeNascimento)  // Exibe a data completa
print(pessoa.$dataDeNascimento)  // Exibe a data formatada

No exemplo acima, usamos $dataDeNascimento para acessar a versão formatada da data. A introdução de projectedValue permite que a lógica adicional seja adicionada sem afetar o valor da propriedade original, mantendo o código limpo e modular.

Observando Propriedades com @Observable

A ideia é simples: ao marcar uma classe com @Observable, todas as suas propriedades que podem ser modificadas ficam automaticamente sujeitas a observação. Quando qualquer uma dessas propriedades muda, o sistema emite um novo valor através de um fluxo assíncrono, que pode ser manipulado por código reativo. Veja um exemplo prático:

swift
Copy code
@Observable

class Unidade {
    var pontosDeVida = 100
}
let unidade = Unidade()
let pontosRestantes = Observations { unidade.pontosDeVida }
for i in 1...5 {
    Task {

        try? await Task.sleep(for: .seconds(2))

        unidade.pontosDeVida -= 10
    }
}
for await pontos in pontosRestantes {
    print("Novos pontos de vida: \(pontos)")
}

Neste exemplo, a classe Unidade é marcada com @Observable, permitindo que o valor de pontosDeVida seja monitorado. Cada vez que a propriedade muda, o código assíncrono reage a essa alteração. Esse mecanismo elimina a necessidade de configurar manualmente observadores e torna o código muito mais simples e reativo.

Conclusão

Os observadores de propriedade e os wrappers de propriedade são ferramentas essenciais para tornar o desenvolvimento em Swift mais eficiente e organizado. Eles permitem que os desenvolvedores se concentrem no comportamento e na lógica de alto nível, enquanto a manipulação de dados e os detalhes do gerenciamento de propriedades ficam encapsulados em estruturas reutilizáveis e modularizadas. Além disso, o uso de @Observable abre novas possibilidades para escrever código reativo de maneira simples e direta, sem a complexidade adicional que outras abordagens podem envolver.

Esses recursos promovem a criação de aplicativos mais responsivos, escaláveis e fáceis de manter. Ao usar esses recursos, você será capaz de escrever código mais limpo e flexível, enquanto mantém a complexidade sob controle. As melhorias de desempenho e clareza que os wrappers de propriedades e os observadores proporcionam são vitais para o sucesso de aplicações Swift, especialmente quando se trabalha com grandes bases de código e precisa-se garantir a escalabilidade e a robustez ao longo do tempo.

Como Swift 6 Gerencia Concurrency e Evita Condições de Corrida em Código Assíncrono

Para ajudar a evitar essas condições de corrida, o Swift 6 introduziu várias melhorias, entre elas, uma verificação rigorosa de concorrência durante o tempo de compilação. O compilador pode analisar o código em busca de potenciais condições de corrida de dados e emitir avisos ou erros quando detecta problemas. Esse tipo de verificação está disponível através de uma funcionalidade opt-in, ou seja, o desenvolvedor precisa habilitá-la para garantir que os problemas de concorrência sejam identificados e corrigidos durante o desenvolvimento.

No Swift 6, entre as principais ferramentas que surgem para evitar essas condições de corrida estão os conceitos de async e await, além de tipos como Actors, Tasks e Task Groups. Esses recursos ajudam a estruturar o código assíncrono de forma mais segura e eficiente, permitindo um controle mais rígido sobre o comportamento das threads.

A utilização dos keywords async e await marca um avanço importante no gerenciamento de tarefas assíncronas. O async é utilizado para indicar que uma função pode suspender sua execução enquanto espera pela conclusão de outra tarefa assíncrona. Por exemplo, uma chamada de rede pode ser executada sem bloquear a thread principal, garantindo que a interface do usuário permaneça responsiva. O await, por sua vez, é usado para invocar funções assíncronas e indica que a execução da função pode ser suspensa até que a tarefa esperada seja completada.

Ao definirmos uma função assíncrona, como mostrado nos exemplos:

swift
Copy code
func retrieveData() async -> String { }

func loadContent() async { }

O Swift permite que o programador crie funções que podem interromper sua execução até que uma operação assíncrona seja finalizada. Isso é visível no exemplo da função retrieveData(), que simula a recuperação de dados com uma pausa de dois segundos usando Task.sleep(nanoseconds:):

swift
Copy code
func retrieveData() async -> String {

    print("Retrieving data")
    try! await Task.sleep(nanoseconds: 2_000_000_000)
    return "Data Retrieved"
}

Essa função imprime uma mensagem de "Recuperando dados", aguarda dois segundos, e então retorna uma mensagem indicando que os dados foram recuperados. O código da função loadContent() demonstra como esperar por essa operação usando await:

swift
Copy code
func loadContent() async {

    let data = await retrieveData()
    print("Data: \(data)")
}

Quando executados, o código exibe a mensagem "Retrieving Data", aguarda dois segundos e então exibe "Data: Data Retrieved". O uso do await aqui não significa que a função será movida para outra thread, mas sim que a execução da função será pausada até que a operação assíncrona termine, permitindo que outras tarefas possam ser executadas enquanto isso.

Quando é necessário chamar múltiplas funções assíncronas, o desafio está em coordená-las de forma eficiente para garantir que todas sejam concluídas corretamente antes de dar continuidade ao processamento. Isso pode ser feito utilizando o conceito de "concurrency" no Swift, como exemplificado a seguir, onde duas funções assíncronas (retrieveUserData() e retrieveImageData()) são chamadas simultaneamente, e a execução só prossegue quando ambas as tarefas são finalizadas:

swift
Copy code
async let userData = retrieveUserData()

async let imageData = retrieveImageData()
let results = await (userData, imageData)
print("User Data: \(results.0) \nImage Data: \(results.1)")

A criação de tarefas assíncronas no Swift é facilitada pela API de Tasks, que oferece um controle ainda mais granular sobre a execução de unidades de trabalho em paralelo. Um exemplo de criação de uma tarefa é o seguinte:

swift
Copy code
Task {
    // código assíncrono aqui
}

Ao lidar com concorrência e dados assíncronos no Swift, é fundamental compreender as limitações e o funcionamento interno dos recursos utilizados, como async, await, Tasks e a nova verificação de concorrência. A eficiência e segurança no uso desses recursos dependem da correta sincronização e gerenciamento das tarefas, evitando condições de corrida e outros erros comuns em ambientes assíncronos.

Como o Design Orientado a Protocolos Pode Transformar a Arquitetura do Código

O Design Orientado a Protocolos (POP, do inglês Protocol-Oriented Programming) é uma abordagem fundamental no desenvolvimento moderno, permitindo criar sistemas mais flexíveis, reutilizáveis e de fácil manutenção. Um dos pilares desse design é o uso de protocolos para definir interfaces de tipos, o que permite que os programadores desenvolvam códigos altamente modulares e com baixo acoplamento. Ao invés de depender exclusivamente de classes, o POP utiliza protocolos para definir os contratos que os tipos devem seguir.

Dentro deste contexto, o uso do where clause em loops é uma técnica poderosa para filtrar os resultados e trabalhar apenas com tipos específicos. No exemplo a seguir, um loop percorre uma lista de veículos e, ao aplicar o filtro de protocolos, executa funcionalidades específicas, como ataques e movimentações terrestres, quando um veículo obedece ao protocolo LandVehicle:

swift
Copy code
for (_, vehicle) in vehicles.enumerated() where vehicle is LandVehicle {

    let vh = vehicle as? LandVehicle
    if vh.landAttack {
        vh.doLandAttack()
    }
    if vh.landMovement {
        vh.doLandMovement()
    }
}

Neste exemplo, o uso do where permite filtrar somente os veículos que se conformam ao protocolo LandVehicle. Esse tipo de abordagem mostra a força da programação orientada a protocolos, pois permite que, ao invés de depender de hierarquias rígidas de herança, o código seja mais flexível e menos propenso a erros.

Outro conceito fundamental no POP é a herança de protocolos. De forma semelhante à herança de classes, protocolos podem herdar os requisitos de outros protocolos. No entanto, ao contrário da herança de classes, onde uma classe pode herdar apenas de uma classe pai, os protocolos podem herdar de múltiplos outros protocolos. Isso resulta em uma hierarquia de protocolos que permite a criação de interfaces mais específicas, sem perder a flexibilidade e a modularidade do código.

A composição de protocolos é outro recurso que adiciona flexibilidade ao design. Por meio dessa técnica, um tipo pode conformar-se a múltiplos protocolos ao mesmo tempo, criando interfaces unificadas e modulares. Isso é especialmente útil em sistemas que precisam combinar diferentes comportamentos de maneira reutilizável e sem a necessidade de herança de classes. Por exemplo, ao invés de criar uma hierarquia complexa de classes, podemos criar protocolos menores e mais focados, e depois combiná-los para criar tipos que atendem a várias necessidades.

Um exemplo dessa técnica de composição pode ser visto na criação de um sistema de informações de pessoas. Podemos definir protocolos como Nameable e Contactable para lidar com o nome e o contato de uma pessoa, respectivamente:

swift
Copy code
protocol Nameable {
    var firstName: String { get }
    var middleName: String? { get }
    var lastName: String { get }
}
protocol Contactable {
    var emailAddress: String { get }
    var phoneNumber: String { get }
}

Usando herança de protocolos, podemos combinar esses dois para formar o protocolo Person, que incorpora tanto as propriedades de nome quanto de contato, e acrescenta mais características, como a data de nascimento e a idade:

swift
Copy code
protocol Person: Nameable, Contactable {

    var birthDate: Date { get }
    var age: Int { get }
    func displayInfo()
}

Dessa forma, qualquer tipo que conformar-se ao protocolo Person herda as propriedades e métodos de Nameable e Contactable, além das características adicionais definidas no protocolo Person.

Além de otimizar o design, a extensão de protocolos também permite adicionar comportamentos padrão para propriedades, como a idade, que pode ser calculada a partir da data de nascimento. Isso reduz a duplicação de código e garante que qualquer tipo que conformar-se ao protocolo Person tenha essa funcionalidade disponível:

swift
Copy code
extension Person {

    var age: Int {
        let now = Calendar.current
        let components = now.dateComponents([.year], from: birthDate, to: Date.now)
        return components.year ?? 0
    }
}

Essa abordagem modular também se aplica a tipos como Employee, que pode herdar de Person e adicionar comportamentos específicos, como as informações sobre o cargo e o salário anual, por meio da composição de protocolos. O código para um funcionário seria assim:

swift
Copy code
protocol Occupation {

    var occupationName: String { get set }
    var yearlySalary: Double { get set }
    var experienceYears: Double { get set }
}
struct Employee: Person, Occupation {
    var firstName: String
    var middleName: String?
    var lastName: String
    var birthDate: Date
    var emailAddress: String
    var phoneNumber: String
    var occupationName: String
    var yearlySalary: Double
    var experienceYears: Double
    func displayInfo() {
        // Exibe as informações do funcionário
    }
}

Ao compor protocolos dessa forma, o código fica flexível, modular e fácil de expandir. Se necessário, podemos criar tipos como Consultant, que não precisa das informações de ocupação, mas ainda assim conforma-se ao protocolo Person:

swift
Copy code
struct Consultant: Person {

    var firstName: String
    var middleName: String?
    var lastName: String
    var birthDate: Date
    var emailAddress: String
    var phoneNumber: String
    func displayInfo() {
        // Exibe as informações do consultor
    }
}

A capacidade de reutilizar componentes como o protocolo Nameable em outros contextos (como um tipo Pet, por exemplo) mostra a robustez do POP. Mesmo em um sistema onde o comportamento de um tipo pode ser completamente diferente, como um Dog, que se conforma ao protocolo Pet, a reutilização de um protocolo modular permite que a arquitetura do código se mantenha coesa e fácil de gerenciar.

A grande vantagem de usar design orientado a protocolos com herança, composição e extensões é a criação de um sistema altamente modular, expansível e fácil de manter. Isso permite que o código cresça de forma organizada, sem se tornar complexo ou difícil de modificar no futuro.