Option Enum

[00:00:00]
>> I'm gonna do something really quick, cuz I do need to kind of speed this section up a little bit. I don't know, I always underestimate how much time things take. But I'm gonna implement the option enough in a small fashion right now. So we can kinda see that there's nothing actually magical happening.

[00:00:14]
And you can do this yourself in rust. And so I'm even try to do something that I didn't practice, just to see what happens, right? So we're gonna go like this, enum Option2 and it's gonna take in a generic. And I'm simply gonna have a None. There's a reason why you always put your empty value up the top.

[00:00:31]
There's like this special memory optimization that when you read too many lists, you can learn about it. But when you're learning a language, don't care about the optimizations. You're just trying to learn the language, then learn the environment then get good at using the language in a speedy practical sense.

[00:00:46]
And then we'll have Sone, which will take a T, there we go. All right, so we have this very beautiful option right here. Now here's one thing that makes rust super awesome, is that I can use the keyword impl and then I can actually impl on the option2.

[00:01:02]
Now this is pretty great, hold on the impl, needs to have a generic and the generic exists right there. So how you read this is effectively there's an implementation that takes in a generic and the generic rest on the type. And so look at this, that means I can actually add functions to my enum.

[00:01:21]
Now this is like my favorite part about rust and it also exists in go as well but you can't do with enums, is that functions are added after you declare the type. And this is kinda different versus classes in JavaScript. You define your class once, and that's what it is.

[00:01:38]
So if you need to add additional behavior, you're either doing inheritance or making your class bigger. Whereas with rust you don't do it that way, it's it's different. I have now specified my type, now I'm specifying my functions. And this doesn't sound like it's the greatest thing ever, but when we start working with strings or iterators and think like that I actually becomes super cool because you can start specifying this additional behavior on top of the of your class.

[00:02:03]
It reminds me lot the goal of react with user effect use state know this, is that you gonna attach behaviors to your component, right? In reality, it's kind of like here's my class, and then here's all my extra properties coming in afterwards or my extra methods of how I get these properties.

[00:02:23]
So it's very composable. And so this allows what I feel like is a bit more composability to your types, that's something like TypeScript just doesn't have or Java if you're more familiar with that. I don't know about C sharp, C sharp is a magical language I haven't seen in a long time.

[00:02:38]
So let's go like this I'm gonna create the exact same function that we had before which is, how about this one, is some. Now that will tell us is this option does it have a value cuz in regular land if I go like this let foo equals some 5, I can go if foo is some, right?

[00:02:56]
Is it a value, then I know for a fact that it's safe to call unwrap. Now usually it's not the best way to do this, you can obviously pattern match the value out as opposed to doing it this way. But there you go, you also have this option.

[00:03:11]
So I can create the exact same thing on mine, where what I need to return out is a Boolean. so what I'll do is I'll return a match of myself, right? This just means this function takes a reference to myself or have the type option. I'm gonna take a reference to myself, and I'm going to match on it.

[00:03:30]
And if I am a None, I'll return false. And if I am a some of doesn't matter of anything, I return burn true, all right? Mitch match types, no. What is it? Okay, so that means I believe it do this. I have to do this or there's always these things you got to play around with.

[00:03:53]
My goodness right here right now, this expression is this. Found this, found emum option T type. We can just do it in a more simple fashion, right? We can do this in a more simple fashion. I can go if let's, I know exactly why, I'm such a fool.

[00:04:09]
Option2, right, remember cuz we've specified our own. Using the same words sometimes causes your brain to make silly mistakes, there we go anyways. So now my special some2, that right here, I now have the exact same thing. Look at that, it works just the same. This is effectively all options are underneath the hood is something just like this, or they just simply have some sort of enum that looks like this.

[00:04:36]
And then they have a bunch of implementations hanging off it. So you can kind of visualize what it is. Now, is it exactly this underneath the hood, probably not. But can you guess what it looks like? Yeah, pretty simple. And if we go like this, some, I can take this and jump to what it looks like.

[00:04:53]
Obviously it has a bunch of like compile time stuff added on top of it. But as you can see, it's just an enum, takes type T, none first cuz remember the memory optimization some T. So it's like literally the same thing that we just built right there. And I bet you if you look around you're gonna find a very similar looking item right here.

[00:05:12]
And is some, let's see if we can find it. Look at that, I don't even know what this thing means. It has some sort of sweet macro that does this and there we go. And so it's almost the exact same thing. Now you can guess what matches does right?

[00:05:25]
Matches just simply take self and is it a some with some? It just does a pattern match on it, right? Okay, easy, we could actually probably even write that if I could write macros fast. But that's sweet, right, none of that should be too hard, right? Let's see I mean I'm just gonna put a new main there so we don't have any errors.

[00:05:42]
So there we go, we just implemented something that looks like the option inside of rust. That's pretty cool, right? It was super cool being able to attach methods. We're gonna do the exact same concept here. You guys can program along and we'll do it. I'm going to not program this, yeah.

[00:05:57]
>> Yeah, so is it impl basically on Java interface?
>> Let's see so, info would be more like so to write this equivalent thing in say TypeScript if this wasn't say this, right? Because we can't do enums with types. Impl is a lot the same as doing class Option2 with a generic on it and then actually having public is some and actually having the concrete value in here.

[00:06:26]
Impl is just the implementation of these functions. And if you want the outside world to be able to see it outside of your file, you had the word pub to it cuz that means that makes it public. Obviously, It'd be really silly to have a public function on something that's not public itself.

[00:06:42]
So if somebody else wanted to use yours and import it in, you'd have to specify it as public. But there you go, exact same concept. Results are here you go, here's all this. We've kind of went over all that. So pretty radical stuff. We've already kind of done some questions.

[00:06:55]
We're gonna keep on moving on.