Value and reference semantics are a bit of a mind boggling topic.

So let's switch to something more straightforward for now.

We started this course by looking at a simple concept, type properties.

Just like we can add properties to the type itself, we can also add type methods.

But you knew this, because we have already written a type method in the past.

When we did that we use the keyword static, but we jumped ahead a bit.

So let's dial it back and work our way through some of the different options and

what they mean.

So we'll add a new comment and

we'll say type methods in here I'll say this is the Value Type section.

So in here let's create a struct again one that we've seen earlier the Map.

When we did this earlier Map also included a type or

a static property origin that contained a point.

So we'll say static let origin and to this we'll assign a point instance.

Given an arbitrary point,

we want to calculate the distance of that point from the origin.

We could make this an instance method but the computation doesn't depend

on any values being assigned to stored properties.

The only information we need given a point

is the location of the origin which is a static property.

And this could be a free function, but

since it deals with an aspect of the Map, we're going to add it to our type.

To create a type method, we're going to start with a keyword static.

After that, we write the method out just like we would any instance method.

So func distance(to point: Point) and this is going to return a double value.

This method takes a point and computes the distance from the origin.

And this involves a bit of math, so I'll just do the work for you.

First we calculate the horizontal distance,

that is the distance between the origin's X coordinate and the point's X coordinate.

So let horizontal distance equal origin.x,

and you'll see here that because this method,

the type method is scoped or is same level as the property.

They're both on the type we can access it here without having to say it Map

origin dot x.

Because both of these are at the Map level and not the instance level.

And this will say minus or subtract point.x.

Similarly we'll need the vertical distance and

we'll use the respective coordinates so origin.why- point.y.

Now to get the distance using these values, again we'll do a bit of math.

And the way we do this is first we're going to square both of these

values then we're going to get this sum of the two and

return the square root of that resulting value.

To square the values we can simply multiply horizontal value by itself but

that kind of makes our code look ugly.

We could write a helper method square that takes a value and

returns the value multiplied by itself.

But if we try that and

add it as an instance method, you'll notice that you won't be able to use

it inside a static method because you first need to create an instance.

Now we could add it as a second type method but

unlike instance methods helper type methods, aren't really a thing.

You only want methods strictly associated with the types functionality,

swift however lets you do a cool thing and

that is nesting functions inside other functions.

So inside this method I can write a small helper function to use.

We'll say func square, it takes a value

and returns a Double value and in here we'll simply say return value * value.

And now we can use this function, because it's available inside this method, we'll

say let horizontalDistanceSquared

= square and pass in the horizontal distance value.

And then we'll do the same thing for the vertical distance.

I'm going to copy that, paste it, and

I'll just change this to vertical and this to vertical.

Okay, for the last bit of logic we need to return the square root

of the sum of these values because again math.

And there's a square root function defined in the foundation framework.

So right over here we'll say import Foundation and

then at the bottom we'll return the value of horizontal distance squared

into that we'll add the value of vertical distance squared.

Right, so first we'll get the sum of these two values and

then return the square root of it.

Notice in this example we're using a value type.

With value types we always declare both type methods and

type properties with the static keyword.

Static here refers to two things.

One, that this method is associated at the type level rather than an instance.

And second that the method is statically dispatched.

A simple way to think about static dispatch is that the compiler knows which

method you intend to call at compile time.

Now hold onto that definition for a second.

By comparing it to dynamic dispatch in the next video

we should be able to get a better understanding of both.