Enum em Swift — o que é, sintaxe e uso

O que é enum em Swift?

Enum (enumeração) é um tipo de dado personalizado que une um conjunto finito de variantes mutuamente exclusivas. Em Swift, enum não são apenas constantes numéricas, mas um tipo completo com sua própria lógica.

Cada variante da enumeração é chamada de caso. Ao contrário do Objective-C, onde enum se reduz a um tipo inteiro, Swift permite que cada caso armazene seus próprios dados e tenha métodos.

De acordo com a Apple, enum em Swift suporta genéricos, inicializadores, propriedades computadas e conformidade com protocolos — tornando-o aplicável para modelar estados, erros, opções e máquinas de estados finitos.

Use enum sempre que precisar representar um conjunto finito de variantes mutuamente exclusivas: estados de tela, tipos de erro, direções, opções de filtro.

Sintaxe de declaração de enum

Enum é declarado com a palavra-chave enum seguida de um nome e um corpo entre chaves.

enum CompassDirection {
    case north
    case south
    case east
    case west
}

Os casos podem ser declarados em uma única linha separados por vírgula:

enum Planet {
    case mercury, venus, earth, mars, jupiter, saturn, uranus, neptune
}

Para acessar um caso, use a sintaxe de ponto após o tipo conhecido:

let direction = CompassDirection.north
// Tipo conhecido — sintaxe abreviada disponível:
var currentPlanet = .earth

Uma vez que uma variável recebe um tipo enum conhecido, o Swift infere automaticamente o tipo, permitindo omitir o nome da enumeração ao acessar os casos.

Raw Values em enumerações

Raw Values são valores de um único tipo atribuídos a cada caso do enum. Ao contrário dos associated values, raw values são do mesmo tipo para todos os casos e são definidos no momento da declaração.

enum HTTPStatusCode: Int {
    case ok = 200
    case notFound = 404
    case internalServerError = 500
}

let code = HTTPStatusCode.notFound
print(code.rawValue) // 404

Para raw values inteiros, o Swift incrementa automaticamente os valores se apenas o primeiro for definido explicitamente:

enum Status: Int {
    case pending = 1
    case active      // 2
    case completed   // 3
}

Raw values podem ser dos tipos Int, String, Character ou qualquer tipo que esteja em conformidade com o protocolo RawRepresentable. Swift gera automaticamente o inicializador init? para criar um enum a partir de um raw value — conveniente para analisar dados de APIs.

Associated Values em enum

Associated Values permitem vincular diferentes tipos de dados a cada caso do enum individualmente. Ao contrário dos raw values, os associated values podem diferir em tipo e quantidade.

enum NetworkError {
    case timeout(seconds: Int)
    case httpError(code: Int, message: String)
    case noConnection
    case unknown(error: Error)
}

Ao processar com switch, os associated values são extraídos através da vinculação a variáveis ou constantes:

let error = NetworkError.httpError(code: 403, message: "Forbidden")

switch error {
case .timeout(let seconds):
    print("Tempo limite excedido após \(seconds)s")
case .httpError(let code, let message):
    print("HTTP \(code): \(message)")
case .noConnection:
    print("Sem conexão")
case .unknown(let err):
    print("Desconhecido: \(err.localizedDescription)")
}

De acordo com a documentação da Apple, os associated values tornam o enum uma ferramenta expressiva para modelar estados complexos sem criar tipos wrapper separados. Use-os para cenários do tipo Result e modelagem de erros com contexto.

Enum recursivo (indirect)

Enum recursivo — uma enumeração cujos casos referenciam o próprio tipo enum. Tais casos são marcados com a palavra-chave indirect.

indirect enum LinkedList<T> {
    case empty
    case node(value: T, next: LinkedList<T>)
}

Usar indirect antes de enum marca todos os casos como recursivos. Alternativamente, você pode marcar apenas um caso específico com indirect:

enum ArithmeticExpression {
    case number(Int)
    indirect case addition(ArithmeticExpression, ArithmeticExpression)
    indirect case multiplication(ArithmeticExpression, ArithmeticExpression)
}

Swift usa indirect para armazenar casos recursivos como referências (semântica de referência) em vez de valores — isso evita o tamanho infinito do enum na pilha. Enums recursivos são amplamente usados na construção de árvores, listas encadeadas e ASTs.

Enum e protocolos

Enum pode estar em conformidade com protocolos assim como estruturas e classes. Este é um recurso-chave da programação orientada a protocolos em Swift.

protocol Describable {
    var description: String { get }
}

enum PaymentMethod: Describable {
    case creditCard(last4: String)
    case applePay
    case bankTransfer

    var description: String {
        switch self {
        case .creditCard(let last4):
            return "Card ending in \(last4)"
        case .applePay:
            return "Apple Pay"
        case .bankTransfer:
            return "Bank Transfer"
        }
    }
}

Enum também pode estar em conformidade com protocolos Cocoa — por exemplo, CaseIterable para geração automática de uma coleção de todos os casos, ou Codable para serialização. Isso torna o enum um bloco de construção versátil em aplicações Swift.