Just like runways, an airport has a finite set of terminals.

So again, let's model it, using a nested enum.

We're going to nest terminal inside control tower, for

the same reason as the runway.

The only object that needs to know about the various terminals in our example

is the control tower.

So, right below the runway type, we'll say enum

Terminal, and create a new type.

Our hypothetical airport will have a few different terminals, so we'll have A,

B, C for domestic flights, and then an international terminal, and

a private hangar.

An airline needs to know both the terminal it will taxi to and

the gate it will park at.

We can define these as separate data points in our landing instructions, but

I think it makes sense to combine them.

Typically, a gate is listed as a ten, where A is the terminal and

ten is the gate number.

So we can list the gate number as an associated value for each enum member.

So we'll say case A, have an associated value, and some optional Int.

I've set a type of optional Int for the associated value,

because we could end up with a situation where the plane is about to land, but

we don't have an open gate yet.

I'm sure you've run into this situation yourself in the real world,

where the plane simply taxis to the terminal and then waits for a gate.

If we don't have an available gate, we can return nil.

So we'll say, case B, and we'll repeat the same thing.

An international terminal.

And finally, we'll say private.

Now the alternative, if we don't have a gate, is to throw an error, but

it's really not an error, is it?

Planes can still land without an open gate.

Now before we can further define the terminal logic,

let's take a quick step back again, and declare an airline type.

Now, this is still not the concrete final type that we're going to use, but

a type that will help us distinguish what kind of airline is coming in.

So, above control tower, I'll say MARK: Airline Type.

In our example, our airport has a few different kinds of flights that come in.

So we have three broad categories, domestic, international, and private.

We have to route each type to a particular terminal.

We've talked about this.

Things, however, get further complicated, because there are several kinds of

domestic flights and they use different terminals based on the fees they pay.

So, let's define an enum to start off with the different domestic

airlines that can land at our airport.

So we'll say enum DomesticAirlineType,

and for this example, we'll say, three different airlines come to our airport,

Delta, American, and United.

So we'll say Delta uses terminal A, American uses B, and United uses C.

Now, remember that empty protocol we created earlier?

AirlineType?

Let's specify that DomesticAirlineType conforms to AirlineType.

Since this is an empty protocol,

it means we don't have to add anything to DomesticAirlineType.

What's even the point, then?

Empty protocols, like AirlineType, are known as marker protocols in Swift.

They allow us to define a higher type to group a few different types.

The airline protocol specifies that conforming types must

indicate the type of airline it is, as you can see here.

This property, the value that we assign, should be of type, AirlineType.

Now, we could have created a single enum called, AirlineType,

and specified every airline that landed at our airport, including domestic,

international, and private.

That's one option.

But doing it this way lets me show you how to use a marker protocol to group

a few different objects to achieve our goal.

Okay, let's add another enum for international airline type.

So I'll say, enum InternationalAirlineType.

Again, conforms to AirlineType, and we'll give a few cases.

So I'll say, case.

You can put whatever you want.

Okay, now that we have our airline types, let's take a small break here.

And in the next video, we'll add a method to our terminal type,

to figure out where the airplane needs to go once it has landed.