Let's try and solve the same problem but get rid of those strings altogether and

use an enum.

To create enum, we start with the enum keyboard and

like any of the other custom types that we've learned about, we give it a name.

Following the convention we've learned about creating custom types,

we're also going to use upper camel case to name enums as well.

So, let's call this Day with an uppercase D.

Just as an aside, the convention is also to give enums, in both structs and

classes, singular name.

So, this will be Day, not days.

Now, inside the body of this enum, we define member values,

or members of the enumeration.

Each member is defined using a case keyword,

which is the same keyword we use inside of a switch statement.

So, let's add our different members.

So, we'll start with case sunday.

Here we have the member for Sunday.

So, this value represents Sunday.

Each day of the week is a different member and

we start each member with a case statement.

So, I'll say case monday.

Note that the convention is that the type name is upper cased but

all values inside the type are lowercase.

So, each case has a lowercase name, lower camel case.

So monday, tuesday, wednesday,

thursday, friday, and finally saturday.

Okay, this is our enum.

Pretty simple.

Well, what's the point of this?

Let's keep going.

So, I'm going to rewrite that function dayType.

So, I'll say func dayType and this is the same as we have up here.

So, we're going to accept a single parameter.

We'll give it an external name of for local name of day.

But unlike the last time, the argument type is not going to be string.

This time we want to use our new custom type, Day, the enum we just created.

For now, we're going to return a string from this function.

Inside the value of a function, we'll do something similar.

Let's add that switch statement again, we'll say switch on day.

And for the first case, we'll check if it's a Saturday or Sunday and

return weekend.

So, we'll say case Day.saturday, and then comma Day.,

and you'll notice something interesting.

The moment I put that dot and

start typing, Xcode starts auto completing for us.

There's that compiler help we were hoping for earlier.

Because this is an actual type we defined with a set range of values,

the compiler knows the different options and presents them.

It makes it impossible to make a mistake.

So Day.saturday and Day.sunday.

Notice how we refer to enum values.

We don't create instances like structs or classes.

Instead we simply use the type, a dot, and then it's like we're accessing a property.

So, Day.saturday and Day.sunday to get these values.

Now, if it's either one of these cases, we'll return Weekend.

Now, let's say I typed sarturday, like that mistake I made earlier.

Well, because this is an actual value and not a string, we typed value,

you'll notice that the compiler complains that the enum case isn't found.

And then suggests a fix to the right type.

With autocomplete, and the compiler help, and its suggested fix,

we've eliminated the possibility of typing an incorrect value.

Now, for the remaining days, well, that's a weekday, right?

So, let's add that in.

So, we'll say, case Day.monday,

Day.tuesday, Day.wednesday,

Day.thursday, and Day.friday.

Then we'll return Weekday.

Now, the body of our function is done.

Wait a minute.

Let's scroll back up and look at the previous function we wrote.

Earlier, over here, we had two cases, just like we do now.

We have "Saturday", "Sunday": return "Weekend", and

then the rest return "Weekday", but we also had a default statement.

So, what's going on here?

Down here we don't have a default statement.

I mentioned at the start of this course that enums are used to model a finite

data set.

Days of the week are a great example of this.

There are seven values to this data set and it will never change.

There will always only be seven values.

The set contains a fixed number of values and

it is this kind of data that an enum models.

It seems like that's a limited use case, but in fact,

there are many ways in which data presents itself like this.

Months of the year, seasons, compass directions, turn by turn navigation

directions, all of these are obvious examples of fixed value data sets.

But what about user state in an app.

Well, that's fixed too.

The user is either logged in or logged out.

That's two states.

What about different reading modes in a book app?

Night mode, regular, and light.

Typically we have three reading modes and these are fixed as well.

The advantage of this is that the compiler can provide some checks for you.

Because our day enum can only ever be seven values, by providing

a return value for all seven cases of the enum, the compiler knows this switch

statement doesn't need a default because all the possible cases are taken care of.

The switch statement is exhaustive,

that is it covers all possible paths without the need for a default value.

And how does it know how many paths there are?

We specify the type of the variable we're switching on in the argument here.

And since the compiler knows it's an enum, we don't have to worry about it.

The compiler keeps a close eye on what we're doing.

For example, if I remove this Day.friday case,

the compiler immediately knows that all paths aren't considered, and

complains that the switch statement must be exhaustive.

I can either add back the Friday case or a default case to fix this.

Pretty neat, right?

There's still a few things we can clean up in our function.

But let's take a break and practice what we just laerned before moving on.