 Now, not only are there this whole variety of concrete types and their parents, the abstract types, you can even create your own. And you can create both abstract and concrete types. Let's start by creating our very own abstract type. We're going to use this abstract keyword, abstract, and let's call it abstract type 1. So we've given it a name and it's going to be an abstract type. There we go, it's created. We've created our very own. Now, if we want to see what the super type is of something that we've just created, let's say abstract type 1, the one that we've created, if we don't call it anything, let me just not misspell it, if we don't allocate it some way, it is going to have any, it's automatically just going to have its parent any. But I can do something else. If I want to inherit something from the number extract types, I can do that. So I can create abstract. Let's call it abstract type 2. And I want that to have a parent number. And that would be what I do. It's the less than equal, less than sign and the colon. So if I were to do that, I've created another abstract type and it has a parent number and it will inherit from its behavior from number. So let's just make sure if I say super abstract type 2 and execute that code cell, I see it has a parent number. Now let's create our own concrete type. So that one's going to be at the bottom of something. And let's have a look at this. So I'm not going to use the keyword concrete. I'm going to use the keyword type. And I'm going to call it whatever I want. I'm going to call it concrete type 1. As I've said there in the example, and it is going to have as its parent abstract type 1, which you remember its parent was just any. Now I can go further. I can give it some fields. Let's call this one field 1 and I'm giving it a field. Now I can call this whatever I want. I needn't have called it this, but I'm going to say that field 2 must be an integer. It must be an integer. And we're just going to end. So not only have I constructed this concrete type. So I can actually make an instance of it. We're going to create an instance of it. I'm also given it these properties. It's got these two properties that it can hold. Field 1 and field 2 and field 2 must be an integer or something that can be converted to an integer. So I can't put a string in there. I can't write the words TWO2. That can't be converted to 2. But I can put in something like 2.0 because 2.0 can be converted to an integer 2. I can't put in 2.1 because 2.1 cannot be converted to an integer. And there we go. It says, let's have a look, field 1, field 2. And it says there for me that the function argument names are not unique. It's a parent of abstract type 1, field 1, and I should call it field 2. So I can also not have these fields obviously named the same thing. There we go. It's executed well. Now I can create an instance of, I can instantiate this type because it's a concrete type. So I'm going to say my variable 1 equals this concrete type and 1. And remember I said I can pass these two arguments to it actually. So let's say hi as I said there in the example and the other one's got to be, it has to be an integer or something that can be converted to an integer. And concrete type, I see I just named it concrete and not concrete type 1. So there we go. We just have to keep things correct there. Now I can access those fields with this dot notation. So I can say var 1 dot field 1, field 1, field 1. There we go. And it says it can return the value that's held inside of that field 1, which is what I passed to it, which was this high. And remember since field 1 was never, it was never specified. I can actually put anything inside of there. And we can actually check that for this instance type of what is var 1 dot field 1. And it says at this time I put in a string. Now just in conclusion, there is a lot more to know about types. Really a lot, lot more. But we're going to come across many of these topics as we cover future lessons. And specifically when we start talking about arrays, which is coming up next and functions, creating functions, we can create and use types inside of those functions to really speed up the execution and write proper Julia code.