 var mathGrade = Grade.B;
 
 mathGrade = .A
+
+print(mathGrade)
 /*:
 ## Switch & Enumerations
 

    case F = "F Grade"
}

let history = GradingScaleStr.A

print(history.rawValue)
/*:
### Implicitly Assigned


}

func count(counting: Count, closure: (number: Int) -> Void) -> Int {

    switch counting {
    case .Number(let number):
        return number
    case let .Forward(from, to):
        let fromNum = count(from, closure: closure)
        let toNum = count(to, closure: closure)

        if(fromNum <= toNum) {
            closure(number: fromNum)

            return count(Count.Forward(Count.Number(fromNum + 1), to), closure: closure)
        }
    case let .Backward(from, to):
        let fromNum = count(from, closure: closure)
        let toNum = count(to, closure: closure)

        if(fromNum >= toNum) {
            closure(number: fromNum)

            return count(Count.Backward(Count.Number(fromNum - 1), to), closure: closure)
        }
    }

    return 0
}

count(Count.Forward(Count.Number(1), Count.Number(10))) { print("forward to \($0)") }
count(Count.Backward(Count.Number(10), Count.Number(1))) { print("backward from \($0)") }
/*:
**Exercise:** Replace each possible tuple property value with an enumeration that would be appropriate to the current non enumeration value.
*/
let iPhone          = (modelName: "iPhone", modelNumbers: ["A1203"], hardwareStrings: ["iPhone1,1"], osVersions: [1, 2, 3])
let iPhone3G        = (modelName: "iPhone 3G", modelNumbers: ["A1324", "A1241"], hardwareStrings: ["iPhone1,2"], osVersions: [2, 3, 4])
let iPhone3Gs       = (modelName: "iPhone 3Gs", modelNumbers: ["A1325", "A1303"], hardwareStrings: ["iPhone2,1"], osVersions: [3, 4, 5, 6])
let iPhone4         = (modelName: "iPhone 4", modelNumbers: ["A1349", "A1332"], hardwareStrings: ["iPhone3,1", "iPhone3,2", "iPhone3,3"], osVersions: [4, 5, 6, 7])
let iPhone4s        = (modelName: "iPhone 4S", modelNumbers: ["A1431", "A1387"], hardwareStrings: ["iPhone4,1"], osVersions: [5, 6, 7, 8, 9])
let iPhone5         = (modelName: "iPhone 5", modelNumbers: ["A1428", "A1429", "A1442"], hardwareStrings: ["iPhone5,1", "iPhone5,2"], osVersions: [6, 7, 8, 9])
let iPhone5c        = (modelName: "iPhone 5c", modelNumbers: ["A1532", "A1456", "A1507", "A1529"], hardwareStrings: ["iPhone5,3", "iPhone5,4"], osVersions: [7, 8, 9])
let iPhone5s        = (modelName: "iPhone 5s", modelNumbers: ["A1533", "A1453", "A1457", "A1530"], hardwareStrings: ["iPhone6,1", "iPhone6,2"], osVersions: [7, 8, 9])
let iPhone6         = (modelName: "iPhone 6", modelNumbers: ["A1549", "A1586"], hardwareStrings: ["iPhone7,2"], osVersions: [8, 9])
let iPhone6Plus     = (modelName: "iPhone 6 Plus", modelNumbers: ["A1522", "A1524"], hardwareStrings: ["iPhone7,1"], osVersions: [8, 9])
let iPhone6s        = (modelName: "iPhone 6s", modelNumbers: ["A1633", "A1688"], hardwareStrings: ["iPhone8,1"], osVersions: [9])
let iPhone6sPlus    = (modelName: "iPhone 6s Plus", modelNumbers: ["A1634", "A1687"], hardwareStrings: ["iPhone8,2"], osVersions: [9])

let phones = [iPhone, iPhone3G, iPhone3Gs, iPhone4, iPhone4s, iPhone5, iPhone5c, iPhone5s, iPhone6, iPhone6Plus, iPhone6s, iPhone6sPlus]
/*:
>> **Constraints:**
* Create the following Enumerations:
    * ModelName = Enumeration for all the modal names
    * ModelNumber = Enumeration for all the modal numbers
    * HardwareString = Enumeration for all hardware string
    * OSVersion = Enumeration for all os versions
* Create the following Functions
    * Create a device passing in as arguments each enumeration
        * Validate the parameters using a guard statement
        * Throw an error that's appropriate to the invalid parameter value
        * Return a tuple similar to above only using the above enumerations
    * Get Device with ModelName
    * Get Device with ModelNumber
    * Get Device with HardwareString
    * Get Devices with OSVersion
*/
/*:
**Checkpoint:**
