Learn how to define and use enumerations in Swift.

Enumerations

Another amazing functionality Swift gives with enumerations is the ability to incorporate computed properties. A computed property is a property that isn’t directly stored but is instead derived from other stored properties of the enumeration. 

Consider this enumeration `Patty`: 

```swift
enum Patty: Int {
    case single = 1
    case double
    case triple
    
    var pattyCountWithExtraPatty: Int {
        return self.rawValue + 1
    }
}

print(Patty.triple.pattyCountWithExtraPatty) // Prints: 4
```
We assign raw integer values implicitly to each of the cases of `Patty`. Then we implement the `pattyCountWithExtraPatty` computed property which returns an integer value equal to one plus what the `rawValue` is currently set to. 

The computed property can return any type of value, and it doesn’t have to be the same as the raw values of the enumeration. In fact, you don’t even have to set raw or associated values for the enumeration cases to implement a computed property in an enumeration.


Implementing a Computed Property in an Enumeration

A switch statement is a common place you might want to use an enum. Switch statements must be exhaustive. This means that each possible case must be addressed explicitly by the control flow. Using an enum type in the switch statement can prevent us from accidentally forgetting to address a case.

Let's look at this switch control flow that uses a `String` type value:

```swift
let myPet = "kitty"

switch myPet {
case "goldfish":
    print("I’m not fluffy but I like to swim")
case "kitty":
    print("I’m fluffy but I’m not a big swimmer")
case "puppy":
    print("I’m fluffy and I love to swim")
default:
    print("I'm not really sure what I am")
}
```
While this works, there is some room for improvement. Because switch statements must be exhaustive, we need to include the default case to cover situations where myPet is equal to a value other than "goldfish", "kitty", or "puppy". However, if we know all of the possible values of `myPet`, then we should always be able to print out the right description. Also, if you add additional cases to the switch statement it could introduce unexpected behavior down the road.

Let see how we can improve the readability and robustness of this code by using an enum:

```swift 
enum Pet {
   case goldfish
   case kitty
   case puppy
}

let myPet = Pet.puppy

switch myPet {
    case .goldfish:
         print("I’m not fluffy but I like to swim")
    case .kitty:
         print("I’m fluffy but I’m not a big swimmer")
    case .puppy:
        print("I’m fluffy and I love to swim")
}

// Prints: I'm fluffy and I love to swim
```

We replaced the `String` `myPet` with an enumeration type called `Pet`. Since we have defined `Pet` to have exactly three cases, we only need to cover those three cases in the switch statement in order to be exhaustive. There is no need for a `default` case because Pet cannot be anything other than a `goldfish`, `kitty`, or `puppy`. By correlating enumeration cases with switch cases, the code becomes more readable since there is no need to handle unexpected pet types. 

Using Enumerations in a Switch Control Flow

Enumerations are a data type found in many popular programming languages, but Swift extends their functionality, offering capabilities one would typically expect to find only in classes. In Swift, enumerations are truly first-class types. 

In this exercise, we will learn how to define and initialize an enum value. 

Enums are defined using the `enum` keyword and curly braces: 

```swift
enum MyDataType {
  // entire enum definition lives here
}
```

Use the `case` keyword to define the cases of your enum:

```swift
enum DogBreed {
  case corgi
  case husky
  case samoyed
  case shibaInu
}
```

You can also shorten your code by entering all cases on a single line separated by commas: 

```swift
enum DogBreed {
  case corgi, husky, samoyed, shibaInu
}
```

To initialize an enum type value, you append the case name to the enum: 

```swift
var bella = DogBreed.samoyed
```

Note that we could also make the variable, `bella`, a constant using `let`, but since we are going to change it, we use a `var`.

One advantage of defining your own enums is that they constrain the values we can assign to them, so if we try to use a case that we haven't defined, we will get a compile-time error: 

```swift
bella = DogBreeds.poodle // Causes compiler error because we have not defined the case of poodle
```

Because the compiler knows `bella` is of the `DogBreed` type, we can safely leave off the `DogBreed` and set the value of `bella` using the shorter dot syntax:

```swift
bella = .corgi
```

Now that we know how to define and initialize enums, let's define one of our own.

What is an Enumeration?

With some forms of information, we know all of the possible values that can exist. Let's say you're building a transportation app.  Users can either travel by truck, plane, or boat.

We could just use a `String` to store that information:

```swift
var myRide = "truck"
```

But that could let us assign `myRide` to something that's not a valid ride type:

```swift
myRide = "winged monkeys"
```

That'd be pretty confusing for a user to see!  Fortunately, Swift allows us to restrict the possible values that a variable could be.

An enumeration, often shortened to enum (pronounced ee-num), is a way to define your own group of related values and work with them in a type-safe manner.  With the enum below, we'll always know which vehicles are valid:

```swift
enum Vehicle {
  case airplane
  case boat
  case truck
}
```

The text reads var myRide: Vehicle = .boat with a boat image, then transitions to a truck and a plane.

Introducing Enumerations

Enumerations aren’t technically one of the three primary collection types offered by Swift (Arrays, Sets, and Dictionaries). However, they do define a set of cases, and you may find yourself in a situation where it is convenient to iterate across all of the cases like you would with a collection. Let's say that you are making an app where the user can select the season:

```swift
enum Season {
    case winter
    case spring
    case summer
    case fall
}
```

We need to be able to iterate over all the seasons to show them in an array. Since enumerations aren't able to do this on their own, we need to utilize a protocol. You'll learn about protocols more in-depth later, but all you need to know now is that protocols define a set of methods and properties that can be adopted by an enumeration.

To iterate over the seasons, we'll use the `CaseIterable` protocol. Here's the syntax: 

```swift
enum Season: CaseIterable {
    case winter
    case spring
    case summer
    case fall
}
```

`CaseIterable` gives us access to a property called `allCases` that returns an array of case values. We'll append this property onto `Season` and iterate over each case with a for loop:

```swift
for season in Season.allCases {
    print(season)
}

/* Prints to the console:
winter
spring
summer
fall 
*/
```

Iterating Over Enumeration Cases

In Swift, enumerations are truly first-class types and have several advanced capabilities. One of those capabilities is the ability to define instance methods inside of an enumeration. 

One such use case is a mutating method within an enumeration. A mutating method is one that changes the values of its instance when executed. Let's revisit our `Season` enum to demonstrate this concept.

```swift
enum Season {
    case winter, spring, summer, fall
    
    mutating func changeSeason() {
        switch self {
        case .winter:
            self = .spring
        case .spring:
            self = .summer
        case .summer:
            self = .fall
        case .fall:
            self = .winter
        }
    }
}  
```

Note that we need to use the `mutating` keyword in the method definition that tells the compiler that `changeSeason()` modifies the value of itself. We use `self` as the value to switch on, then each case of the switch statement modifies the value of `self` accordingly. So as we would expect, depending on what the value of the Season instance is, `changeSeason()` will change its own instance to the appropriate value. 

Now we can declare the current season and initially set it to winter. Note that we need to use a variable for the current season since we will change its value when we call `changeSeason()`

```swift
var currentSeason = Season.fall
currentSeason.changeSeason()

print(currentSeason)

// Prints: winter
```

Implementing Methods in Enumerations

Great job 🙌 We have learned about the power and flexibility offered by Swift enumerations. Here’s what we covered: 

* What an enumeration is
* How to use enumerations in a switch control flow
* How to iterate over enumerations cases like a collection
* Defining raw values in an enumeration
  * Explicitly and implicitly assigning raw values
  * Extracting raw values for cases
  * Initializing an instance with a raw value
  * All cases must have the same type of raw value
* Defining associated values in an enumeration
  * Associated values can be differently typed for each case
  * All cases don’t need associated value
* Implementing methods in enumerations
  * Use of mutating methods
* Defining computed properties in enumerations

Enumerations are indeed first class citizens in Swift and can help you write clean, expressive code 🛩 

Reviewing What We Learned

One of the powerful functionalities Swift adds to enums is the ability to store an associated value of any type attached to a case value. This is different from raw values because each case can have a different type of associated value or no associated value at all. 

To show how we can define an enum with an associated value, let's start with this enum describing desserts:

```swift
enum Dessert {
    case cake
    case vanillaIceCream
    case brownie
}
```

We might have some business logic that needs to know how many scoops of ice cream we are serving or the particular flavor of the cake. We can define associated values for the `Dessert` enum using the following syntax:

```swift
enum Dessert {
    case cake(flavor: String)
    case vanillaIceCream(scoops: Int)
    case brownie
}
```

To instantiate an enum with an associated value we use the following syntax:

```swift
let tonightsSpecial = Dessert.vanillaIceCream(scoops: 4)
``` 

To access the associated values, we can extract them in a switch statement

```swift
switch tonightsSpecial {

case let .cake(cakeFlavor):
    print("Time for \(cakeFlavor) cake")
case let .vanillaIceCream(scoopCount):
    print("\(scoopCount) scoops of vanilla ice cream")
case .brownie:
    print("Decadent goodness")
}

// Prints: 4 scoops of vanilla ice cream
```

By using the `let` syntax in parenthesis after the switch case statement we extract the associated value as a constant. 

If an enumeration has a raw value, its cases can't have associated values. This is because it wouldn't be able to recreate both the case and the associated value from a single input.

Let's add an associated value to our Vehicle enum ✈️

Using Associated Values with Enumerations

In some other programming languages, enumerations are built using another underlying type. For example, in C++, enumerations are actually a set of integers. 

The Swift implementation of enumerations is much more flexible, allowing you to assign a raw value to each case. You can assign Strings, Characters, Ints, Doubles, and Floats as a raw value. However, you can only assign one raw value type per enumeration. This could be useful for situations where each case has a value attached to it that is used by your code logic in some capacity.

```swift
enum Emoji: String {
    case bee = "🐝"
    case brain = "🧠"
    case heartEyes = "😍"   
}
```
By using the `: String` syntax and the assignment operator `=`, we explicitly assign each of the `Emoji` enumeration cases underlying raw String values. 

We access the raw values using the `.rawValue` property. 

```
print(Emoji.brain.rawValue) // Prints: 🧠
```

If we use Int or String raw values, we can also implicitly assign values for each case by explicitly assigning the first case like so: 

```swift
enum Team: Int {
    case alpha = 1
    case bravo
    case charlie
    case delta
}

print(Team.delta.rawValue) // Prints: 4
```

Because the first case, `alpha`, is assigned the integer value of `1`, the compiler infers that `bravo` should have a raw value of `2` and so on. If you use Strings as raw values and do not explicitly assign a value, the compiler will use the name of the case as its raw value. 

Once we assign raw values for an enumeration, we can then initialize an instance using a raw value like so: 

```swift 
enum Weekday: Int {
    case monday = 1 
    case tuesday 
    case wednesday 
    case thursday 
    case friday
}

let birthday = Weekday(rawValue: 3)

// birthday is of type Weekday? and equals Weekday.wednesday
```

You might be wondering what the question mark on `Weekday?` means. The `?` symbol indicates an `Optional` type which means the value can either be some value or a nil value. We will be covering Optionals in-depth in a later lesson, but you can learn more about them [here](https://docs.swift.org/swift-book/LanguageGuide/TheBasics.html#ID330). 

Because it is possible that someone enters a raw value that isn’t assigned to any case in the `Weekday` enumeration, initializing from a raw value can return `nil`. 

If you create an enumeration with `String` raw values and don't provide any values, the raw value will be the same as the case name:

```swift
enum Status: String {
    case complete
    case pending
    case rejected
}

let myStatus = Status.complete
print(myStatus.rawValue) // Prints: complete
```