Como Utilizar Tipos de Valor e Tipos de Referência em Swift para um Código Eficiente e Bem Gerido

A distinção entre tipos de valor e tipos de referência é fundamental para escrever código eficiente e fácil de gerenciar em Swift. Cada pedaço de dado com o qual trabalhamos se encaixa em uma dessas duas categorias, e cada uma delas possui características únicas que afetam a gestão de memória, a mutabilidade e o desempenho do nosso código. Compreender essas diferenças e semelhanças entre tipos de valor e tipos de referência nos permite tomar decisões informadas ao projetar nossas aplicações, assegurando que estamos otimizando o desempenho e a gestão de memória, ao mesmo tempo que mantemos um código limpo e de fácil manutenção.

Quando falamos em passar uma instância de um tipo de valor, isso implica que uma cópia da instância precisa ser criada. Isso pode levantar preocupações quanto ao desempenho, especialmente com tipos de valor que podem crescer significativamente em tamanho ao ser movimentados entre diferentes partes do código. Para resolver isso, podemos implementar mecanismos como o "copy-on-write", que veremos mais adiante.

swift
Copy code
struct GradeValueType {
    var name: String
    var assignment: String
    var grade: Int
}

A estrutura GradeValueType define três propriedades: duas do tipo String (name e assignment) e uma do tipo Int (grade). Já o tipo de referência, a classe GradeReferenceType, é definida da seguinte forma:

swift
Copy code
class GradeReferenceType {

    var name: String
    var assignment: String
    var grade: Int
    init(name: String, assignment: String, grade: Int) {
        self.name = name
        self.assignment = assignment
        self.grade = grade
    }
}

Embora ambas as implementações definam as mesmas propriedades, a classe GradeReferenceType exige um inicializador explícito, enquanto a estrutura GradeValueType tem um inicializador padrão. Isso ocorre porque, ao contrário das classes, as estruturas fornecem um inicializador automático caso não seja especificado um inicializador personalizado.

Agora, vamos olhar para um exemplo de como essas instâncias podem ser criadas:

swift
Copy code
var ref = GradeReferenceType(name: "Jon", assignment: "Math Test 1", grade: 90)

var val = GradeValueType(name: "Jon", assignment: "Math Test 1", grade: 90)

Embora a criação de instâncias de ambos os tipos seja semelhante, o comportamento deles é completamente diferente. Para ilustrar isso, criaremos duas funções que alteram as notas desses tipos:

swift
Copy code
func extraCreditReferenceType(ref: GradeReferenceType, extraCredit: Int) {

    ref.grade += extraCredit
}
func extraCreditValueType(val: GradeValueType, extraCredit: Int) {
    val.grade += extraCredit
}

Essas funções recebem uma instância de um dos nossos tipos e um valor de crédito extra. No entanto, ao tentar usar a função extraCreditValueType(), um erro será gerado, pois o parâmetro do tipo GradeValueType é imutável por padrão. Isso ocorre porque estamos recebendo uma cópia do valor, e as estruturas são passadas por valor. Já os tipos de referência, como a classe GradeReferenceType, são passados por referência, permitindo que qualquer modificação na instância seja persistida.

Além disso, ao trabalhar com tipos de valor, é importante notar que o gerenciamento de memória pode ser mais direto, pois o Swift lida com a alocação e desalocação de memória de maneira eficiente quando os tipos de valor saem de escopo. Já os tipos de referência exigem uma gestão mais cuidadosa, uma vez que o Swift usa contagem de referências para garantir que a memória seja liberada quando não houver mais referências ativas para a instância.

Entender essas diferenças é crucial não só para escrever código eficiente, mas também para evitar bugs difíceis de encontrar, especialmente em programas mais complexos. Saber quando usar um tipo de valor ou referência pode melhorar significativamente o desempenho e a legibilidade do código. Quando lidamos com tipos de valor, devemos ter cuidado com a cópia de grandes estruturas, e quando lidamos com tipos de referência, devemos garantir que as modificações em uma instância sejam controladas e não resultem em efeitos colaterais inesperados.

Como o API Mirror pode ser útil para inspecionar tipos no Swift?

O uso de reflexão em programação oferece uma maneira poderosa de inspecionar e interagir com tipos e objetos durante a execução. No Swift, o Mirror API fornece um meio de acessar informações sobre os objetos no momento da execução, mas é importante compreender as implicações de desempenho e os cenários em que seu uso é adequado.

Vamos explorar como funciona a API Mirror e como podemos aplicá-la de maneira eficaz com alguns exemplos práticos.

Primeiramente, vamos criar uma estrutura simples chamada Person que contém três propriedades: firstName, lastName e age. O código abaixo demonstra como inicializar uma instância de Person e criar um espelho para ela:

swift
Copy code
struct Person {

    var firstName: String
    var lastName: String
    var age: Int
}
let person = Person(firstName: "Jon", lastName: "Hoffman", age: 55)
let mirror = Mirror(reflecting: person)

swift
Copy code
print("Display Style: \(mirror.displayStyle!)")
print("Subject Type: \(mirror.subjectType)")

O displayStyle fornece informações sobre o tipo subjacente do objeto. Ele pode indicar se o objeto é uma classe, estrutura ou até mesmo um tipo opcional, enquanto o subjectType nos diz o nome do tipo do objeto, que no nosso caso seria "Person".

A saída desse código seria algo assim:

mathematica
Copy code
Display Style: Optional(Swift.Mirror.DisplayStyle.struct)

Subject Type: Person

Além disso, podemos examinar as propriedades do objeto Person utilizando a coleção children da instância mirror. Essa coleção contém as propriedades armazenadas do objeto, como mostramos a seguir:

swift
Copy code
for (label, value) in mirror.children {

    print("Property: \(label ?? "Unknown"), Value: \(value)")

}

A saída para esse código seria:

yaml
Copy code
Property: firstName, Value: Jon
Property: lastName, Value: Hoffman
Property: age, Value: 55

Outro ponto de interesse ocorre quando trabalhamos com herança de classes. Considere a seguinte hierarquia de classes:

swift
Copy code
class Vehicle {
    var numberOfWheels: Int
    init(numberOfWheels: Int) {
        self.numberOfWheels = numberOfWheels
    }
}
class Car: Vehicle {
    var numberOfDoors: Int
    init(numberOfDoors: Int) {
        self.numberOfDoors = numberOfDoors
        super.init(numberOfWheels: 4)
    }
}

Ao criar uma instância da classe Car, o Mirror irá refletir apenas as propriedades definidas dentro da classe Car. Para acessar as propriedades da superclasse Vehicle, precisamos usar o superclassMirror:

swift
Copy code
let car = Car(numberOfDoors: 4)

let mirrorCar = Mirror(reflecting: car)
print("Display Style: \(mirrorCar.displayStyle!)")
print("Subject Type: \(mirrorCar.subjectType)")
if let mirrorCarSuper = mirrorCar.superclassMirror {
    print("Super Class: \(mirrorCarSuper.subjectType)")
    for (label, value) in mirrorCarSuper.children {
        print("Property: \(label ?? "Unknown"), Value: \(value)")
    }
}

Isso irá gerar a seguinte saída:

yaml
Copy code
Display Style: Optional(Swift.Mirror.DisplayStyle.class)

Subject Type: Car
Super Class: Vehicle
Property: numberOfWheels, Value: 4

Notamos que, ao inspecionar a instância da classe Car, o Mirror exibe apenas as propriedades dessa classe. Para refletir as propriedades da superclasse Vehicle, usamos superclassMirror para acessar a estrutura da classe pai.

Além disso, o API Mirror possui suas limitações quando se trata de exibição de informações personalizadas. Para isso, existe o protocolo CustomReflectable, que nos permite controlar exatamente o que será refletido quando nosso tipo for inspecionado. Isso é particularmente útil quando precisamos ocultar informações sensíveis, como senhas, ou quando desejamos um formato de exibição mais legível para depuração.

Por exemplo, podemos criar uma estrutura Person com informações privadas, como uma senha, e implementar o protocolo CustomReflectable para controlar a exibição:

swift
Copy code
struct Person {

    var firstName: String
    var lastName: String
    var userName: String
    var age: Int
    var password: String
}
extension Person: CustomReflectable {
    var customMirror: Mirror {
        let fullName = "\(firstName) \(lastName)"
        return Mirror(self, children: [
            "firstName": firstName,
            "lastName": lastName,
            "userName": userName,
            "fullName": fullName,
            "age": String(age)
        ], displayStyle: .struct)
    }
}

Aqui, o campo password foi explicitamente excluído da reflexão, garantindo que informações sensíveis não sejam expostas:

swift
Copy code
let person = Person(firstName: "Jon", lastName: "Hoffman", userName: "MyUser", age: 55, password: "MyPass123!")

let mirror = Mirror(reflecting: person)
for (label, value) in mirror.children {
    print("Property: \(label ?? "Unknown"), Value: \(value)")
}
print("Display Style: \(mirror.displayStyle!)")
print("Subject Type: \(mirror.subjectType)")

A saída seria:

yaml
Copy code
Property: firstName, Value: Jon

Property: lastName, Value: Hoffman
Property: userName, Value: MyUser
Property: fullName, Value: Jon Hoffman
Property: age, Value: 55
Display Style: struct
Subject Type: Person

Isso demonstra como a reflexão pode ser personalizada e otimizada para diferentes necessidades, seja para melhorar a legibilidade dos logs ou para proteger dados sensíveis.

Por fim, é fundamental compreender que, embora a API Mirror ofereça grande flexibilidade, ela também pode adicionar overhead computacional significativo, especialmente em operações em tempo real. Portanto, seu uso deve ser cuidadoso, especialmente em partes de um aplicativo que exigem alto desempenho. Em muitos casos, pode ser mais eficiente optar por soluções alternativas, como armazenar dados explicitamente ou usar técnicas de serialização, em vez de depender de reflexão para acessar informações em tempo de execução.

Como Usar Funções Assíncronas e Controlar Execução Concorrente com Grand Central Dispatch (GCD)

Existem momentos em que é necessário executar tarefas com um atraso específico. Em um modelo baseado em threads, seria necessário criar uma nova thread, aplicar uma função de atraso, como um sleep, e depois executar a tarefa. Porém, com o Grand Central Dispatch (GCD), podemos usar a função asyncAfter para realizar a execução assíncrona de um bloco de código após um determinado tempo de espera. Isso é útil, por exemplo, quando é necessário pausar a execução do código em um ponto específico.

A função asyncAfter é chamada sobre uma fila de despacho, e o código a seguir mostra como podemos utilizá-la. Criamos uma fila serial e determinamos o tempo de atraso para a execução da tarefa:

swift
Copy code
let queue2 = DispatchQueue(label: "squeue.hoffman.jon")

let delayInSeconds = 2.0
let pTime = DispatchTime.now() + delayInSeconds
queue2.asyncAfter(deadline: pTime) {
    print("Time's Up")
}

Aqui, a fila de despacho é criada, e após um tempo de 2 segundos, a mensagem "Time's Up" é impressa no console. O GCD facilita essa abordagem sem a necessidade de criar novas threads manualmente, simplificando o processo de gerenciamento de tarefas assíncronas com atraso.

swift
Copy code
let queue = DispatchQueue(label: "cqueue.hoffman.jon", attributes:.concurrent)
let dispatchGroup = DispatchGroup()
dispatchGroup.enter()
queue.async {
    print("async1 started")
    performCalculation(10_000, tag: "async1")
    print("async1 completed")
    dispatchGroup.leave()
}
dispatchGroup.enter()
queue.async {
    print("async2 started")
    performCalculation(1_000, tag: "async2")
    print("async2 completed")
    dispatchGroup.leave()
}
dispatchGroup.notify(queue: DispatchQueue.main) {
    print("All tasks are complete")
}

Os grupos de despacho são extremamente úteis quando temos várias tarefas independentes que precisam ser executadas simultaneamente, mas queremos aguardar sua conclusão antes de prosseguir com outra parte do código. Isso é fundamental quando lidamos com operações paralelas, como downloads, cálculos, ou tarefas de rede.

swift
Copy code
let workItem = DispatchWorkItem {

    for i in 1...9 {

        if workItem.isCancelled {
            print("workItem was cancelled")
            break
        }
        print("Executing \(i)")
        Thread.sleep(forTimeInterval: 1)
    }
}
workItem.notify(queue: DispatchQueue.main) {
    print("workItem has completed")
}
DispatchQueue.global(qos: .background).async(execute: workItem)
let delayInSeconds = 4.0
DispatchQueue.global().asyncAfter(deadline: .now() + delayInSeconds) {
    print("Cancelling workItem")
    workItem.cancel()
}

Neste código, criamos um DispatchWorkItem que executa uma contagem de 1 a 9, pausando por um segundo em cada iteração. O item de trabalho pode ser cancelado a qualquer momento, como demonstrado no final, quando o item é cancelado após um atraso de 4 segundos. Além disso, a função notify() permite que executemos um bloco de código quando o item de trabalho for concluído ou cancelado.

swift
Copy code
let delayInSeconds = 4.0

let delayTime = DispatchTime.now() + delayInSeconds

DispatchQueue.main.asyncAfter(deadline: delayTime) {
    print("After a \(delayInSeconds) second delay.")
}

Ao utilizar DispatchTime, obtemos a hora atual do sistema e adicionamos o valor do atraso a ela. Isso é útil quando precisamos definir tempos de execução precisos baseados no relógio do sistema. No entanto, vale a pena notar que o DispatchTime pausa a contagem quando o dispositivo entra em modo de suspensão.

swift
Copy code
let delayInSeconds = 4.0

let delayTime = DispatchWallTime.now() + .seconds(5)

DispatchQueue.main.asyncAfter(wallDeadline: delayTime) {
    print("After \(delayInSeconds) second delay.")
}

Neste exemplo, DispatchWallTime.now() nos dá a hora do "mundo real", que continua avançando mesmo quando o dispositivo entra em modo de economia de energia ou suspensão.

Por fim, outra característica importante do GCD é o uso de barreiras para garantir a execução ordenada de tarefas em filas concorrentes. O uso de barreiras permite que uma tarefa específica seja executada de maneira isolada, garantindo que nenhuma outra tarefa da fila seja executada até que ela termine. Veja um exemplo:

swift
Copy code
let queue = DispatchQueue(label: "cqueue.hoffman.jon", attributes: .concurrent)

queue.async {
    print("async1 started")
    performCalculation(30_000, tag: "async1")
    print("async1 completed")
}
queue.async {
    print("async2 started")
    performCalculation(10_000, tag: "async2")
    print("async2 completed")
}
queue.async(flags: .barrier) {
    print("async3 started")
    performCalculation(100_000, tag: "async3")
    print("async3 completed")
}
queue.async {
    print("async4 started")
    performCalculation(100, tag: "async4")
    print("async4 completed")
}

Neste código, a tarefa "async3" é marcada com a flag .barrier, o que significa que ela será executada isoladamente, sem que as outras tarefas concorrentes sejam iniciadas até que sua execução seja concluída. Esse controle é útil quando precisamos garantir que operações de leitura e escrita de dados em paralelo sejam coordenadas corretamente, evitando condições de corrida.

É essencial entender que o GCD, com suas funções como asyncAfter, DispatchGroup, DispatchWorkItem, e DispatchTime, oferece uma maneira poderosa de controlar a execução de tarefas assíncronas e concorrentes em aplicativos. O uso apropriado dessas ferramentas pode otimizar o desempenho e garantir a integridade do código, evitando problemas de sincronização e melhorando a responsividade do aplicativo.

Como funcionam os closures e por que eles tornam o código mais expressivo

Closures são blocos de código autocontidos que podem ser tratados como valores: atribuídos a variáveis, passados como parâmetros ou retornados de funções. Eles encapsulam comportamento e estado, criando uma forma poderosa de abstração e reutilização de lógica. Assim como um Int representa um número inteiro e um String representa texto, um closure representa uma sequência de instruções que pode ser executada, possivelmente recebendo parâmetros e retornando valores.

A sintaxe básica de um closure em Swift reflete a de uma função, mas sem a necessidade de nomear o bloco de código. Utiliza-se a palavra-chave in para separar a definição de parâmetros e tipo de retorno do corpo do closure. Por exemplo:

swift
Copy code
let closureSimples = { () -> Void in
    print("Olá Mundo")
}

Esse closure não recebe parâmetros e não retorna valor. Sua função é apenas imprimir uma mensagem. Ele é executado como se fosse uma função comum: closureSimples().

Closures podem ser parametrizados. Um closure que recebe um nome como String e imprime uma saudação pode ser definido assim:

swift
Copy code
let saudacao = { (nome: String) -> Void in

    print("Olá \(nome)")
}

Executado com saudacao("João"), ele imprime “Olá João”. Um detalhe importante: ao invocar um closure, não se usa o nome do parâmetro como em funções nomeadas — apenas os valores.

A utilidade real dos closures aparece ao passá-los como parâmetros. Essa capacidade cria código altamente modular. Por exemplo:

swift
Copy code
func executarSaudacao(handler: (String) -> Void) {
    handler("Luna")
}
executarSaudacao(handler: saudacao)

A função executarSaudacao recebe um closure que aceita um String e retorna Void. Dentro da função, ela executa o closure, que imprime a saudação com o nome fornecido.

Closures também podem retornar valores. Um exemplo:

swift
Copy code
let criarMensagem = { (nome: String) -> String in

    return "Olá \(nome)"
}
let mensagem = criarMensagem("Maple")
print(mensagem)

Essa abordagem permite transformar lógica em funções reutilizáveis e anônimas que retornam dados, não apenas executam efeitos colaterais.

Swift oferece ainda uma sintaxe reduzida para closures, ideal para expressões compactas, geralmente com uma única linha de execução. Ao omitir tipos e nomes explícitos de parâmetros, usa-se identificadores como $0, $1, etc., representando os parâmetros na ordem em que aparecem.

Por exemplo, dado:

swift
Copy code
func executarRepetidamente(vezes: Int, acao: () -> Void) {

    for _ in 0..<vezes {
        acao()
    }
}

É possível passar um closure diretamente:

swift
Copy code
executarRepetidamente(vezes: 3) {

    print("Executando...")
}

A clareza que closures trazem é inseparável de sua concisão. Ao eliminar a necessidade de declarar funções auxiliares nomeadas para lógicas simples e reutilizáveis, o código se torna mais direto, próximo de uma linguagem natural. No entanto, isso exige disciplina: a legibilidade nunca deve ser sacrificada pela brevidade excessiva.

Além disso, a capacidade de capturar estado permite que closures atuem como "funções com memória", o que pode ser explorado para manter valores internos entre execuções ou criar funções parcialmente aplicadas. Isso abre espaço para técnicas avançadas como currying, composição funcional, ou construção de DSLs (Domain Specific Languages), especialmente quando combinados com result builders, que também permitem escrever estruturas de dados complexas com sintaxe declarativa, semelhante a SwiftUI.