enum SomeEnumeration {
 // enumeration definition goes here
}

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

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

var directionToHead = CompassPoint.west

directionToHead = .east

directionToHead = .south
switch directionToHead {
case .north:
 print("Lots of planets have a north")
case .south:
 print("Watch out for penguins")
case .east:
 print("Where the sun rises")
case .west:
 print("Where the skies are blue")
}
// Prints "Watch out for penguins"

let somePlanet = Planet.earth
switch somePlanet {
case .earth:
 print("Mostly harmless")
default:
 print("Not a safe place for humans")
}
// Prints "Mostly harmless"

enum Barcode {
 case upc(Int, Int, Int, Int)
 case qrCode(String)
}

var productBarcode = Barcode.upc(8, 85909, 51226, 3)

productBarcode = .qrCode("ABCDEFGHIJKLMNOP")

switch productBarcode {
case .upc(let numberSystem, let manufacturer, let product, let check):
 print("UPC: \(numberSystem), \(manufacturer), \(product), \(check).")
case .qrCode(let productCode):
 print("QR code: \(productCode).")
}
// Prints "QR code: ABCDEFGHIJKLMNOP."

switch productBarcode {
case let .upc(numberSystem, manufacturer, product, check):
 print("UPC : \(numberSystem), \(manufacturer), \(product), \(check).")
case let .qrCode(productCode):
 print("QR code: \(productCode).")
}
// Prints "QR code: ABCDEFGHIJKLMNOP."

enum ASCIIControlCharacter: Character {
 case tab = "\t"
 case lineFeed = "\n"
 case carriageReturn = "\r"
}

enum Planet: Int {
 case mercury = 1, venus, earth, mars, jupiter, saturn, uranus, neptune
}

enum CompassPoint: String {
 case north, south, east, west
}
CompassPoint.south 的隐式原始值是"south", 以此类推。
let earthsOrder = Planet.earth.rawValue
// earthsOrder is 3
 
let sunsetDirection = CompassPoint.west.rawValue
// sunsetDirection is "west"

let possiblePlanet = Planet(rawValue: 7)
// possiblePlanet is of type Planet? and equals Planet.uranus

let positionToFind = 11
if let somePlanet = Planet(rawValue: positionToFind) {
 switch somePlanet {
 case .earth:
  print("Mostly harmless")
 default:
  print("Not a safe place for humans")
 }
} else {
 print("There isn't a planet at position \(positionToFind)")
}
// Prints "There isn't a planet at position 11"

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

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

let five = ArithmeticExpression.number(5)
let four = ArithmeticExpression.number(4)
let sum = ArithmeticExpression.addition(five, four)
let product = ArithmeticExpression.multiplication(sum, ArithmeticExpression.number(2))

func evaluate(_ expression: ArithmeticExpression) -> Int {
 switch expression {
 case let .number(value):
  return value
 case let .addition(left, right):
  return evaluate(left) + evaluate(right)
 case let .multiplication(left, right):
  return evaluate(left) * evaluate(right)
 }
}
 
print(evaluate(product))
// Prints "18"