Como criar subscritos genéricos e trabalhar com tipos associados em Swift

Em Swift, a criação de subscritos genéricos permite que tipos de dados sejam manipulados de maneira flexível, sem a necessidade de definir explicitamente os tipos ao criar as funções. Um exemplo básico de subscript genérico é o seguinte:

swift
Copy code
struct HashProvider {
    subscript(item: T) -> Int {
        return item.hashValue
    }
}

swift
Copy code
subscript(item: T) -> Int where T: Hashable {
    return item.hashValue
}

Isso permite que passagens de instâncias de qualquer tipo que seja Hashable possam ser usadas nesse subscript. A flexibilidade dos subscritos genéricos não se limita apenas aos parâmetros, mas também pode ser estendida para o tipo de retorno. Exemplo:

swift
Copy code
subscript(key: String) -> T? {

    return dictionary[key] as? T
}

Aqui, o subscript retorna um tipo genérico T, permitindo que o tipo de retorno seja definido de maneira flexível, conforme o tipo de T.

Agora, passemos para a explicação dos tipos associados, um recurso importante no Swift. Um tipo associado declara um nome de espaço reservado para um tipo concreto que será especificado somente quando o protocolo for adotado por uma estrutura ou classe. Para declarar um tipo associado dentro de um protocolo, usamos a palavra-chave associatedtype:

swift
Copy code
protocol QueueProtocol {

    associatedtype QueueType
    mutating func add(item: QueueType)

    mutating func getItem() -> QueueType?

    func count() -> Int
}

O protocolo QueueProtocol define um tipo associado chamado QueueType. Ele é utilizado dentro do protocolo tanto como o tipo do parâmetro do método add() quanto como o tipo de retorno do método getItem(). Isso significa que qualquer tipo que adote esse protocolo precisa fornecer uma definição concreta para o tipo de QueueType e garantir que os métodos do protocolo manipulem apenas instâncias desse tipo.

Para implementar esse protocolo, podemos criar uma classe como a IntQueue, que utiliza o tipo Int:

swift
Copy code
class IntQueue: QueueProtocol {
    var items = [Int]()
    func add(item: Int) {
        items.append(item)
    }
    func getItem() -> Int? {

        return items.count > 0 ? items.remove(at: 0) : nil

    }
    func count() -> Int {
        return items.count
    }
}

Essa classe implementa os métodos definidos pelo protocolo, substituindo o tipo QueueType por Int. Como resultado, a fila criada pela IntQueue só pode conter inteiros, e suas operações são feitas especificamente com esse tipo.

Se quisermos criar uma fila mais flexível, podemos optar por uma implementação genérica, onde o tipo QueueType é substituído por um tipo genérico T:

swift
Copy code
class GenericQueue<T>: QueueProtocol {
    var items = [T]()
    func add(item: T) {
        items.append(item)
    }
    func getItem() -> T? {

        return items.count > 0 ? items.remove(at: 0) : nil

    }
    func count() -> Int {
        return items.count
    }
}

Agora, a classe GenericQueue pode manipular qualquer tipo, dependendo do tipo T fornecido quando a instância é criada. Aqui, a fila se torna mais versátil, e podemos utilizá-la para armazenar qualquer tipo de dado que precisarmos:

swift
Copy code
var intQueue = GenericQueue<Int>()
intQueue.add(item: 2)
intQueue.add(item: 4)
print(intQueue.getItem()!)  // Imprime 2

A flexibilidade dos tipos associados também pode ser aprimorada com restrições de tipo. Por exemplo, se quisermos garantir que o tipo usado em QueueType seja um tipo Hashable, podemos adicionar a restrição da seguinte maneira:

swift
Copy code
associatedtype QueueType: Hashable

Isso garante que, ao adotar o protocolo QueueProtocol, o tipo QueueType será obrigatoriamente um tipo que adere ao protocolo Hashable, permitindo que ele seja usado em operações que exigem comparações de hash, como em coleções como conjuntos ou dicionários.

Outro avanço importante que o Swift introduziu foi o conceito de existenciais implicitamente abertos, que surgiram com o SE-0352 na versão 5.7 do Swift. Antes dessa versão, quando usávamos protocolos com tipos associados, não podíamos tratá-los como tipos diretamente. Era necessário recorrer a técnicas de "type erasure" ou códigos adicionais para lidar com protocolos como tipos. A partir do Swift 5.7, foi possível utilizar a palavra-chave any para indicar que um protocolo com tipos associados pode ser tratado como um tipo, simplificando a utilização desses protocolos:

swift
Copy code
protocol Drawable {

    func draw()
}
struct Circle: Drawable {
    func draw() {
        print("Drawing a circle")
    }
}
struct Square: Drawable {
    func draw() {
        print("Drawing a square")
    }
}
func drawAll(_ items: [any Drawable]) {
    for item in items {
        item.draw()
    }
}

A compreensão adequada de como usar tipos associados, subscritos genéricos e protocolos é crucial para dominar a programação em Swift, especialmente quando trabalhamos com estruturas de dados flexíveis e reutilizáveis. A chave está em entender como essas ferramentas podem ser combinadas para criar código eficiente e escalável, ao mesmo tempo que mantemos a clareza e a segurança do tipo.

Como o Grand Central Dispatch (GCD) Revoluciona o Gerenciamento de Tarefas no iOS e macOS

O principal problema ao utilizar threads é que as aplicações podem rodar em uma grande variedade de sistemas e processadores, e, para otimizar o código, é necessário saber quantos núcleos ou processadores poderiam ser eficientemente utilizados em um dado momento — informação que geralmente não está disponível no momento do desenvolvimento. Para resolver esse problema, muitos sistemas operacionais, incluindo o iOS e o macOS, começaram a utilizar funções assíncronas. Essas funções são comumente usadas para iniciar tarefas que podem levar um tempo considerável para serem concluídas, como fazer uma requisição HTTP ou escrever dados no disco. Uma função assíncrona geralmente inicia uma tarefa longa e então retorna antes que a tarefa seja concluída. Normalmente, essa tarefa é executada em segundo plano e utiliza uma função de retorno (como uma closure em Swift) para ser notificada quando a tarefa terminar.

O GCD oferece filas de despacho para gerenciar as tarefas enviadas. Essas filas lidam com as tarefas enviadas e as executam em uma ordem FIFO (First-In, First-Out), garantindo que as tarefas comecem na ordem em que foram enviadas. Uma tarefa é qualquer trabalho que a nossa aplicação precise realizar, como cálculos simples, ler ou escrever dados no disco, fazer uma requisição HTTP ou lidar com outras tarefas necessárias. Definimos essas tarefas colocando o código dentro de uma função ou closure e as adicionamos a uma fila de despacho.

O GCD oferece três tipos de filas de despacho:

• Filas seriais: As tarefas em uma fila serial (também conhecida como fila privada) são executadas uma de cada vez, na ordem em que foram enviadas. Cada tarefa começa somente após a tarefa anterior ser concluída. As filas seriais são frequentemente usadas para sincronizar o acesso a recursos específicos, pois garantem que nenhuma duas tarefas na fila rodarão simultaneamente. Portanto, se o acesso a um recurso específico for restrito às tarefas dentro de uma fila serial, nenhuma duas tarefas tentará acessar esse recurso simultaneamente ou fora de ordem.

• Filas concorrentes: As tarefas em uma fila concorrente (também conhecida como fila de despacho global) executam-se de forma concorrente, mas ainda começam na ordem em que foram adicionadas à fila. O número de tarefas que podem ser executadas ao mesmo tempo varia e depende das condições e recursos atuais do sistema. A decisão de quando iniciar uma tarefa, além da ordem em que as tarefas foram enviadas, é gerenciada pelo GCD e não é algo que podemos controlar dentro da nossa aplicação.

• Fila principal de despacho: A fila principal de despacho é uma fila serial globalmente disponível que executa tarefas no thread principal da aplicação. Como as tarefas na fila principal de despacho são executadas no thread principal, ela é normalmente usada para atualizar a interface do usuário após o processamento em segundo plano ser finalizado.

Criando e Usando Filas de Despacho

Antes de explorarmos como usar as filas de despacho, vamos criar algumas funções que nos ajudarão a demonstrar como as várias filas funcionam.

A primeira função que criaremos simplesmente realizará alguns cálculos básicos e retornará um valor. O código dessa função é o seguinte:

swift
Copy code
func doCalc() {
    let x = 100
    let y = x * x
    _ = y / x
}

swift
Copy code
func performCalculation(_ iterations: Int, tag: String) {
    let start = CFAbsoluteTimeGetCurrent()

    for _ in 0 ..< iterations {

        doCalc()
    }
    let end = CFAbsoluteTimeGetCurrent()
    print("time for \(tag):\(end - start)")
}

Essas funções serão usadas juntas para manter as filas ocupadas e assim podemos ver como elas funcionam.

Para criar uma fila de despacho, utilizamos o inicializador DispatchQueue. O código a seguir mostra como criá-la:

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

let serialQueue = DispatchQueue(label: "squeue.hoffman.jon")

A primeira linha cria uma fila concorrente com o rótulo cqueue.hoffman.jon, enquanto a segunda cria uma fila serial com o rótulo squeue.hoffman.jon.

As filas de despacho oferecem uma maneira eficiente e flexível de realizar concorrência em sistemas modernos. Por meio delas, é possível gerenciar a execução de tarefas de maneira controlada e eficiente, aproveitando ao máximo os recursos de hardware disponíveis, sem complicar o código e sem precisar gerenciar diretamente as threads. A adaptabilidade das filas, junto com a simplicidade do uso das funções assíncronas, representa um avanço significativo na maneira como lidamos com a concorrência no desenvolvimento de aplicativos no ecossistema Apple.

Como as Funções de Primeira Classe e Funções de Ordem Superior Facilitam a Programação Funcional em Swift

As funções puras são um dos pilares dessa filosofia. Elas se caracterizam por gerar a mesma saída sempre que recebem as mesmas entradas e não causam efeitos colaterais, ou seja, não alteram o estado global ou os dados fora de seu escopo local. Esse comportamento previsível torna o código mais fácil de testar e depurar.

Outro conceito essencial são as funções de primeira classe, que permitem tratar funções como cidadãos de primeira classe no código. Isso significa que as funções podem ser atribuídas a variáveis, passadas como argumentos para outras funções e até mesmo retornadas por outras funções, exatamente como outros tipos de dados. Com as funções de primeira classe, técnicas poderosas como currying e composição de funções podem ser implementadas, facilitando a criação de código mais modular e legível.

Além disso, as funções de ordem superior são outro conceito central na programação funcional. Uma função de ordem superior é capaz de receber funções como argumentos, retornar funções como resultado ou ambos. Isso permite que o código seja mais abstrato, modular e reutilizável. Por exemplo, podemos criar uma função que aceita uma das duas funções matemáticas, add ou subtract, como argumento e aplica a operação correspondente. Isso ilustra como funções de ordem superior podem ser usadas para aumentar a flexibilidade do código e permitir que funções sejam combinadas de maneira dinâmica, dependendo do contexto.

Swift, como linguagem funcional moderna, oferece suporte robusto para técnicas avançadas, como composição de funções, currying e recursão. A composição de funções é uma técnica particularmente poderosa, pois permite combinar várias funções para criar uma nova função composta. Esta técnica facilita a construção de soluções mais legíveis e reutilizáveis, uma vez que permite que funções simples sejam combinadas de maneira sequencial para formar operações mais complexas.

Por exemplo, considere duas funções simples: addOne() que soma 1 a um número e toString() que converte um número em uma string. A composição dessas funções pode resultar em uma nova função que primeiro soma 1 ao número e depois converte o resultado em uma string. Em Swift, isso pode ser feito com a criação de uma função composta que aplica addOne e, em seguida, toString ao número fornecido. Além disso, é possível criar operadores personalizados para facilitar a composição de funções. Um exemplo de operador infixo, como o >>>, pode ser usado para compor funções de maneira concisa e expressiva, aplicando a saída de uma função como entrada para a próxima, criando uma cadeia de transformações.

Entender como essas técnicas funcionam e como aplicá-las corretamente em Swift não só melhora a qualidade do código, mas também permite a criação de sistemas mais flexíveis e escaláveis.