For our next bit of code, let's define a struct which we'll

call User to represent a user in this hypothetical app of ours.

In our app, we're often going to refer to our user with their full name, so

we want to have a full name property.

We could simply add the full name, but that doesn't enforce it.

It's up to me to do that if I want.

So instead, let's make the user struct conform to the fully nameable protocol.

A protocol can be adopted by a class, struct or

enumeration and these objects can then define an implementation for

the requirements that are specified by the protocol.

So let's see what this looks like.

After the name of the struct User,

we're going to add a colon followed by the name of the protocol.

This looks a lot like how a class specifies a superclass or

base in its inheritance hierarchy, but that's not what this is.

You'll notice though in a moment that when you do this, you have an error.

When you specify that a type that is a class struct or

enumeration adopts a protocol, you have to provide an implementation

as described by the protocol to conform to it.

The FullNameable protocol states that you must have a stored property

called FullName, so let's add that.

We'll say, var fullName, of type String.

Notice the moment we add this, the error goes away.

Also take note of the fact that I specified the type here to be string.

Now, what if I change this to an integer?

Again, we get an error and if we click it,

it says that type user does not conform to the protocol.

And it says here,

the fix says protocol requires a property full name with a type String.

All right, so let's change that again.

Our protocol not only requires that you have a property called FullName but

also that it is of type string.

Any type that satisfies the requirements of a protocol

is said to conform to that protocol.

In this case,

we're saying that the User struct conforms to the FullNameable protocol.

Now, let's create an instance of user with the full name.

So, let’s say let user = User, and

we'll give it a name.

Like I said earlier, we could have simply added the stored property without having

to conform to a protocol.

The advantage of specifying the protocol is that it provides an expectation

of certain attributes or behavior.

By identifying that User conforms to full nameable,

we know that it must have a property called FullName.

Protocols can require that conforming types have specific instance properties,

instance methods, type methods, which we don't know about yet, and so on.

Remember, I said that a protocol only describes an implementation but

doesn't actually provide one.

So let's define another struct.

We'll call this one Friend.

Now, Friend is going to have, oops, let's go back up.

Friend is going to have a firstName stored property of type String.

A middle name, we'll make this non-optional

just to be easy and finally a last name stored property.

Okay, now let's adopt FullNameable again.

So struct Friend conforms, or adopts, FullNameable.

Again, we get an error because Friend now does not have a full name property.

Now, this time we're going to add a computed property for full name that

creates a full name automatically using values from the other stored properties.

We haven't learned about computed properties just yet.

Don't worry, we'll spend more time on them in the future.

A computed property, all you should know for now,

lets you create a property that determines its value through some computation,

hence the name computed property.

You cannot assign it a value directly and it has no storage.

So to do that, we'll say var fullName and then like a function,

we'll open a set of braces here and inside we'll say return and

we'll create an interpolated string here

to return the first name, middle name and last name.

Now we can create an instance of friend, so I'll say let friend equal.

And give it some values.

And then we can get a value for full name.

We can get this friend's full name by using the full name property.

Notice a very important thing here.

Both user and friend conform to the fullNameable protocol but

they differ in their implementation.

In the case of User,

we assigned a value to fullName when we initialized an instance.

Whereas with the instance of Friend, we assign a value to firstName,

middleName and lastName and then use those three properties to compute a full name.

This is an important characteristic of protocols.

All our FullNameable protocol says is that you need to have a full name property.

It doesn't say how you should get this property.

Can you assign a value to it or do you compute it from other properties?

None of that matters.

It specifies what should be implemented, but

does not require a specific implementation.

That is left up to the class structure or enumeration that adopts it.

We'll see how this is useful as we go through the course.