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


var dir = Direction.west
dir = Direction.east
dir = .north
print(dir)

enum Direction2{
    case north,south,east,west
}

let dir2 = Direction2.east
print(dir2)

switch dir2 {
case .north:
    print("north")
case .south:
    print("south")
case .east:
    print("east")
case .west:
    print("west")
}

enum Score{
    case points(Int)
    case grade(Character)
}

var sc = Score.points(96)
sc = .grade("A")


switch sc {
case let .points(i):
    print(i,"points")
case let .grade(i):
    print(i,"grade")
}

//输出
//A grade

enum Date{
    case digit(year:Int,month:Int,day:Int)
    case string(String)
}

var date = Date.digit(year:2019,month:9,day:10)
date = .string("2019-9-10")

switch date {
case .digit(let year,let month,let day):
    print(year,month,day)
case .string(let i):
    print(i)
}

//输出
//2019-9-10

do{
    enum Grade:String{
        case perfect = "A"
        case great = "B"
        case good = "C"
        case bad = "D"
    }
    
    var grade = Grade.perfect
    grade = Grade.good
    print(grade)//good（原始值）
    
    switch grade {
    case .perfect:
        print(grade.rawValue)//C（隐式原始值）
    case .great:
        print(grade.rawValue)
    case .good:
        print(grade.rawValue)
    case .bad:
        print(grade.rawValue)
    }
}

do{
    enum Grade:String{
        case perfect,great,good,bad
    }
    
    let grade = Grade.great
    print(grade)//great

    switch grade {
    case .perfect:
        print(grade.rawValue)//great
    default:
        print(grade.rawValue)
    }
}

enum Season:Int{
    case spring = 1,summer,autumn = 4,winter
}
print(Season.spring)//spring
print(Season.summer.rawValue,Season.winter.rawValue)//2 5
}

func enumRecursion() -> Void {
    //1、使用举例

    indirect enum ArithExpr{
        case number(Int)
        case sum(ArithExpr,ArithExpr)
        case difference(ArithExpr,ArithExpr)
    }

    func calculate(_ expr:ArithExpr)->Int{
        switch expr {
        case let .number(value):
            return value
            
        case let .sum(left,right):
            return calculate(left) + calculate(right)
            
        case let .difference(left,right):
            return calculate(left) - calculate(right)
        }
    }


    let five = ArithExpr.number(5)
    let four = ArithExpr.number(4)
    let two = ArithExpr.number(2)
    
    let sum = ArithExpr.sum(five,four)
    let difference = ArithExpr.difference(sum,two)

    print(calculate(difference))
}

func memorylaoutUse() -> Void {
    //1、查看类型的内存占用
    let a5 = 10
    print(MemoryLayout<Int>.size)       //8
    print( MemoryLayout<Int>.stride)    //8
    print(MemoryLayout<Int>.alignment)  //8
    
    print(MemoryLayout.size(ofValue: a5))       //8
    print( MemoryLayout.stride(ofValue: a5))    //8
    print(MemoryLayout.alignment(ofValue: a5))  //8

    //2、查看枚举的内存占用（关联值）
    enum Password{
        case num(Int,Int,Int,Int)
        case other
        case other2
    }
    
    print(MemoryLayout<Password>.size)//33 实际占用的内存大小
    print(MemoryLayout<Password>.stride)//40 分配的内存大小
    print(MemoryLayout<Password>.alignment)//8 对齐参数
    
    let num = Password.num(0, 1, 2, 3)
    let other = Password.other
    print(MemoryLayout.size(ofValue: num))//33
    print(MemoryLayout.size(ofValue: other))//33
    


    //3、查看枚举的内存占用（原始值）
    enum Season5{
        case spring,summer,autumn,winter
    }
    print(MemoryLayout<Season5>.size)//1
    print(MemoryLayout<Season5>.stride)//1
    print(MemoryLayout<Season5>.alignment)//1
    
    
    enum Season52:Int{
        case spring = 1,summer,autumn,winter
    }
    print(MemoryLayout<Season52>.size)//1
    print(MemoryLayout<Season52>.stride)//1
    print(MemoryLayout<Season52>.alignment)//1

    let sea:Season52 = Season52.autumn
    print(MemoryLayout.size(ofValue: sea))//1

}