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"