1.枚舉語法

    enum Some{
            //枚舉定義
    }

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

多個成員值可以出現在同一行上，用逗號隔開

    enum Some{
            case north,south,east,west
    }
    每一個枚舉定義了一哥全新的類型：
    var aa = Some.east
    簡寫： var aa = .east

2.使用Switch語句匹配枚舉

    aa = .east
    switch aa{
            case .north:
                   print()
             case .south:
                   print()
             case .east:
                   print()
             case .west:
                   print()
     }

3.關聯值

在定義枚舉的時候，可以為該成員變設置關聯值

    enum some{
            case aa(Int,Int,Int,Int)
            case bb(String)
    }
    調用：var cc = some.aa(1,2,3,4)
    或者簡寫： var cc = .aa(1,2,3,4)

關聯值可以被提取出來作為 switch 語句的一部分。你可以在switch
的 case 分支代碼中提取每個關聯值作為一個常量（用let
前綴）或者作為一個變量（用var前綴）來使用：

    switch cc{
            case aa(let a,let b,let c,let d):
                      print(a,b,c,d)
            case bb(let str)
                       print(str)
    }

如果一個枚舉成員的所有關聯值都被提取為常量，或者都被提取為變量，為了簡潔，你可以只在成員名稱前標注一個let
或者var

    switch cc{
            case let aa( a, b,c, d):
                      print(a,b,c,d)
            case let bb( str)
                       print(str)
    }

4.原始值

• 原始值的隱式賦值
  在使用原始值為整數或者字符串類型的枚舉時，不需要顯式的為每一個枚舉成員設置原始值，swift會自動為你賦值。
  當使用整數作為原始值時，隱式賦值的值依次遞增1，如果第一個枚舉成員沒有設置原始值，其原始值為0

    enum aa :Int{
            case a = 1, b , c , d
    }
  

  String類型枚舉成員的枚舉值是它本身。
  通過枚舉成員的 rawValue屬性可以訪問該枚舉成員的原始值

  let b = aa.b.rawVlaue       //2
  

• 使用原始值初始化枚舉實例

    enum aa :Int{
            case a = 1, b , c , d
    }
    let b = aa(rawValue:3)
    //b 的類型為 aa,值為c
  

注意，并不是左右的值都可以找到匹配的枚舉成員 ，因此原始值構造器總是返回一個可選的枚舉成員，
原始值構造器是一個可失敗構造器，因為并不是每一個原始值都有與之對應的原始值，如果沒有，則為nil

5.遞歸枚舉

是一種枚舉類型，有一個或多個枚舉成員使用該枚舉類型的實例作為關聯值。使用遞歸枚舉，編譯器會插入一個中間層，可以在枚舉成員前加上indirect來表示該成員可遞歸

    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 .Number(let value):
            return value
        case .Addition(let left, let right):
              return evaluate(left) + evaluate(right)
          case .Multiplication(let left, let right):
            return evaluate(left) * evaluate(right)
            }
       }
      print(evaluate(product))
      // 輸出 "18"