Neste artigo sobre Swift, falaremos sobre enums.

Enumerações (ou enums) são encontradas na maioria das linguagens de programação como forma de associar um símbolo com um conjunto de membros em um grupo fechado de alternativas. Em alguns casos, os valores associados a um enum não têm um significado (por exemplo, Macho, Fêmea) e, em outros casos, carregam dados úteis (ex: Leste pode ter um valor de 90 e Nordeste de 45).

Linguagens tradicionais representam uma enumeração sempre como um pseudônimo (alias) para um valor integral e usam um truque para substituir o valor na hora da compilação, como um conjunto de constantes #define. Apesar de isso funcionar, significava que enums poderiam ser substituídos um pelo outro mesmo que isso não fizesse sentido (ex: Macho == Norte).

Os enums no Swift são mais poderosos, e tipos enum são distintos, mesmo que representem os mesmos valores. Como resultado, não é possível equiparar dois enums, a menos que eles sejam do mesmo tipo.

Por exemplo, para criar um enum simples que represente gênero:

Definindo uma enumeração de Gênero

Welcome to Swift!  Type :help for assistance.
  1> enum Gender {
  2.   case Male
  3.   case Female
  4. }

Não há comparação ou ordenação entre os diferentes elementos; eles são como propriedades e podem ser tanto uma como a outra. O tipo enumeração pode ser utilizado como tipo do argumento, tipo do retorno ou tipo da variável, utilizando uma sintaxe de pontos – assim como nas estruturas.

Usando uma enumeração de Gênero

  5> let alblue:Gender = Gender.Male
alblue: Gender = Male
  6> alblue == Gender.Male
$R0: Bool = true
  7> alblue == Gender.Female
$R1: Bool = false

Como o Swift sabe que o tipo da variável é Gênero, não é necessário informar o tipo da enumeração neste momento de uso. Isso tem exatamente o mesmo efeito:

Usando uma enumeração de Gênero com apenas um tipo enum

  8> let alblue:Gender = .Male
alblue: Gender = Male
  9> alblue == .Male
$R2: Bool = true
 10> alblue == .Female
$R3: Bool = false

Isso é comumente visto quando se passam bandeiras ou outras propriedades em uma função Swift. Particularmente, a maioria das constantes existentes no código fonte de Objective-C (como o UIDeviceOrientation) são expostos como enumerações Swift, significando que apenas o valor pode ser usado (como .UIDeviceOrientationPortrait).

Enumerações também podem guardar valores junto com seus tipos. Por exemplo, em física nuclear, átomos são feitos de Quarks, que podem ter uma propriedade de cor associada Vermelho, Azul ou Verde. Isso pode ser representado como enumerações, desta forma:

Representando Quarks em Swift

 11> enum QuarkColor {
 12.   case Red, Blue, Green
 13. }
 14> enum Quark {
 15.   case Up(colour:QuarkColor)
 16.   case Down(colour:QuarkColor)
 17.   case Charm(colour:QuarkColor)
 18.   case Strange(colour:QuarkColor)
 19.   case Top(colour:QuarkColor)
 20.   case Bottom(colour:QuarkColor)
 21. }
 22> let proton = [
 23.   Quark.Up(colour:.Red),
 24.   Quark.Up(colour:.Green),
 25.   Quark.Down(colour:.Blue)
 26. ]
proton: [Quark] = 3 values {
  [0] = Up = { colour = Red }
  [1] = Up = { colour = Green }
  [2] = Down = { colour = Blue }
}
 27> let neutron = [
 28.   Quark.Up(colour:.Red),
 29.   Quark.Down(colour:.Green),
 30.   Quark.Down(colour:.Blue)
 31. ]
neutron: [Quark] = 3 values {
  [0] = Up = { colour = Red }
  [1] = Down = { colour = Green }
  [2] = Down = { colour = Blue }
}

Os valores em um enum também podem ser utilizados em padrões em uma instrução switch. Por exemplo, para representar um naipe de uma carta de baralho é possível representar ambos: os naipes e valores das cartas.

 32> enum Suit {
 33.  case Clubs, Diamonds, Hearts, Spades
 34. }
 35> enum Rank:Int {
 36.  case Two = 2, Three, Four, Five
 37.  case Six, Seven, Eight, Nine, Ten
 38.  case Jack, Queen, King, Ace
 39. }
 40> enum Card {
 41.  case Face(Rank, Suit)
 42. }

Da mesma forma que valores como Card.Face(.Ace,.Spades) podem ser usados para criar uma carta, eles também podem ser usados para encontrar uma carta correspondente:

 43> let card:Card = .Face(.Ace,.Spades)
card: Card = Face {
  Face = { 0 = Ace, 1 = Spades }
}
 44> switch card {
 45.   case .Face(.Ace,_): println("Smoke me a kipper")
 46.   case .Face(_,.Hearts): println("♥")
 47.   default: println("Try again")
 48. }
Smoke me a kipper

O uso de enums como um padrão para correspondência de objetos é muito útil para estruturas de dados fungíveis, como structs. No entanto, não é presumível que enums sejam objetos plenos; na verdade, eles são úteis em representar estados ortogonais para um sistema em particular; seja um quark ou uma carta.

No próximo artigo, vamos ver como fazer programação mais funcional com o Swift. Não deixe de acompanhar.

***

Artigo traduzido pela Redação iMasters, com autorização do autor. Publicado originalmente em http://alblue.bandlem.com/2014/10/swift-structs-overview.html