[MUSIC]

In Swift, there's several different ways to codify or represent information and

logic, functions, types and interfaces or protocols.

We've seen so far that functions and types can be made generic.

So what about protocols?

You might think of a protocol as already something generic,

in that any type can conform to a protocol.

But what about the internals of a protocol?

Can we define a protocol where the requirements themselves are generic?

We can, but not in the same way as we've seen so far.

With protocols, we have a different concept called associated types.

So if a new playground page open here and

we're going to model a new data structure in this video.

Except we're not going to provide a full implementation like we just did.

We'll start by defining an interface through a protocol.

So we'll call this protocol Stack.

A stack is essentially an array with limited functionality.

You can push a new element to the top of a stack pop to remove the element

from the top and peek at the top element without popping it.

The main point of this stack is the order.

A stack operates on last in, first out order.

The element you most recently pushed is the one you get back when popped.

Let's defined this interface.

So in here, first step is the push function.

Assuming we set up the stack using a struct,

like an array, then push will be a mutating method.

And we need to indicate that to the compiler.

So we'll start with mutating func push.

The method is going to take a single argument,

an element to push on to the stack.

Now here's the tricky part.

What type do we give this method?

Remember, we want this method to have a generic requirement.

Any concrete type of stack that we need to create needs to be able to conform to this

protocol and work despite it containing strings, or integers, or whatever.

The end goal is that each stack class or

struct that we create has to contain one type only.

What we need here is an associated type.

So right above the function, let's type out the keyword

associatedtype followed by a name we want to give this associated type.

This name is just like how we name our type parameters in a generic function.

So we'll call this element.

And now back in the function, we can specify the type as a type of argument.

Just like type parameters, associated types give a placeholder name to a type

that is used as part of the protocol.

The actual type to use for

that associated type is not specified until we actually adopt the protocol.

Okay, so let's add two other requirements.

Pop returns the last element we pushed onto the stack

which also mutates the stack.

So we'll say mutating func pop and this is going to return the last element.

Finally, we have peak which lets us look at the very last element without popping

it and we'll call this top.

Pretty simple.

Now let's see how we can go from an associated type to more concrete usage.

There are two ways we can do this.

So we'll declare a stack of ints, so

I'll call a struct IntStack and we'll conform to the stack protocol.

The first way to satisfy the associated type requirement is to be explicit and

state it in code.

We do this by using the type alias keyword and

indicating that element which is the associated type in our protocol

is a type alias for a concrete type inside this object.

So we can say typealias or if you start typing at Element,

it should say Element equal Type and add that typealias keyword automatically.

And you will see that element is always going to be an integer inside this struct.

Now all the methods push and

pop take integers instead of our generic requirement element.

Let's provide a really quick implementation.

We'll use an underlying array for storage and make it private, so let's say private

var array and this is an array that is generic over int.

And for the implementations of the method, we'll just use this array, so

push just appends it to that array that we just created.

Pop removes and returns the last element from the array.

So we'll say return pop array.popLast.

And finally, top just reads the last element in the array.

Pretty simple except we seem to have some errors, what's going on?

All right, we need to make this mutating and here as well,

we still seem to have this error, so let's check.

Okay, this seems to be a problem with my playground.

It should work on your end,

let's quickly go back to a different page and see if we can make it work.

Okay, now I said there were two ways of doing this and the second way is to simply

let the compiler infer the type for the associatedtype requirement.

By specifying the argument type or the return type for

all the methods as integer, the compiler can infer that we've substituted int for

the associatedtype because those say element over here.

So we can just get rid of this typealias declaration and

everything should still work.

So this is how you give the protocol generic requirements.

This seems pretty simple but we can actually do quite a bit with this.

Before we go down that road though, let's learn a bit more about type constraints.