Rust Programming Language Rust Malaysia, 9 Mar 2022

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Rust Meetup March 2022

Description

Ivan Tham will be giving a talk about traits (and static dispatch and dynamic dispatch).

A

Hello, everyone well welcome to the rust meetup much.

A

Today, today we will have, we will be having the rasmita match and for those people that want that is, live okay, you can switch to the discord channel. You can post questions in chat or you can wait until the event is over. Then you can ask the question.

A

The topic of the day is about traits, but before I start out I'll be I'll be using I'll be hosting. Today. Before I start, I will be giving.

A

I'll be doing some news on russ what happened before before this and yeah. So since the last meetup there is, uh they announced russ 1.59, and the interesting thing is that they released the inline assembly.

A

So it's stabilized now and you can you can do the inline inline assembly with the using the macro asm macro, and you can also do the destructuring assignments previously. You can only do you can can do the structuring, but you need to put that in the front, but now you can assign you can assign to the values here.

A

So that's the new interesting stuff that is being released for the last for the last release.

A

You could, you would say, major release.

A

Now, let's switch to now, let me switch to the other screen.

A

For the participants, if you have any questions, feel free to feel free to just post in a chat or.

A

Or you can you can just ask us during the ask, during the just just in the discord, yeah I'll, do I'll reply. There.

A

As part of it originally, the plan was to talk about raspberries and static, dynamic dispatch, but I think just frustrating enough will be will be enough and the examples on the slides given below will be structured in the story form to show like why and how why? Why is there rush trades, that's just based on my own, based on my own findings and some I just took from the rust book and some other referrals like rfc.

A

So what was wrong trade roast rate is like uh similar to like the class and something not not very similar. But it's something like that and you can. You can know easily in chinese a mandarin, you call person and it's like characteristic like so it describes how it describes how something behaves the the word in english if they call it, but it's less commonly used.

A

So the transfer is easier to understand the equal person and you can also consider it as part of op or p is object, oriented programming, but in this case trade don't do the inheritance, it does composition, inheritance inside you have one eye. You have one one class inherit from another class and it inherits all the data. But composition is more like uh you only have you only define the functions it have and you can?

A

You can have multiple you can you can have multiple trades for one for one item and there is a as like the other composition. Usually that is for us straight there's, no data, so there's only methods or some of other languages are called contracts.

A

So is that inside the public behavior of how how that function, interacts with other functions and for raspberry is also integrated with the rest of the system like unsafe, generate lifetime type inference we might go with. We might discuss a few of this within the talk and trade must be in scope to be able to cause method it just it's just one of the behavior of fresh trade such that. If the, if the trade is out of scope, then you can't already call it later we'll talk about that.

A

So right, let's, let's talk about why our trades needed so there's a story and of two of concepts of opposing forces, and one is called genius called young thing. There are so called material energy, so there's one structure called yin and one structure called so. This is uh called a unit struct in in rust, where it's also it's a unit, and it's also struck, so you can think of it.

A

Just like one one, one variable or structure something like that, but it you have it's a structure that is empty or something, and so both of them implement the same function. Mpl implies.

A

Is like a lot of synthetic sugar, but in means that gene have a these are all methods under yin, so in has its light function, so this is called method, so this function will output a boolean false. So if you do in column, column is like, then it will return false, and so this is return, but for those not familiar the last item in the last item inside the block like this is the block.

A

So the last item inside will be the return or we need any expression. Basically, the last item will return out of the scope, so this will be written out of the function. So this this will be written false and this will be written through. So young is like is true and, and then there comes, then you have you need to. You need to do a function to create a function to check. If an item is like so okay, so then we do it slide and what this is a function.

A

Defense is a function and this parameter is like this is just the variable name. I just keep, I just add, underscore in front to silent the compiler and I'm here fn bull means this is a variable of a function with no with no, I no arguments and returns a bull. So basically the same. ah You see you see basically the same thing here, but impl here means something that in something that implements this and it returns nothing. Basically, it's nothing here, so you can think of it's like a generic function or something like that.

A

But this is not it's not it's not there's no generics involved here then, when you run so invest you when you want to run something you need to put fn main. This will be the function you write so like. If so, this will be the function run in in the file. Then it's like so this. This works this compiles and as we know, everything will change, and now we have, we need to have another function.

A

Chord is one just now we have it's like so means that got the light, and then now we have another function is one and then we implement the same thing as we know uh you. If, if you know about this, you might have heard is one in is zero. That's what I heard so I put zero false and yang is one true. Okay,.

A

And then oh, and we have to create another function, this one here this one, then we need to do this. You'll notice, that if we do this right, can we it's very hard to differentiate in I'm pl fm bo is very hard to differentiate this and this. So it's one that I passing in is one, but I could have passed in. Yin is like if I, if by passing yin, is like it's false.

A

It's one false okay, this lucky, because both of them return the same output, but then there's no guarantee that we pass in the wrong function here and then it it does something it does wrongly.

A

So as as we notice that, if, if if the function becomes more complicated, but if we right now, we need to have a more complicated function that takes in both both the previous function. Let's say we have a function that ecm and the first parameter is whether or not it gets a it gets a function that returns, whether it's light or not, and another is a function. Two returns is one another, so we need to put it young.

A

It's like and yam is one here and okay. You notice that if we have more parameters, then it's getting harder to track.

A

So what if we could do something that can represent all of them, then? Oh, so that's why we have trades so trades to rescue.

A

So why is trades for trace is to define the shared behavior like the, so both of them can be grouped under something we can call it energy, so the energy have the we can give define or energy must have these two functions. One function is a slide, and another function is one so, but you'll notice that it's a bit different because for a trade we must always put in the we must always put in this. The first parameter itself.

A

Basically, this is also a synthetic sugar. This means okay, next.

A

So basically, this synthetic sugar means that it takes in itself as.

A

Energy, basically, basically, this is a significant sugar for this. Basically, these two is the same thing. Don't worry about don't if, for those new to rats, don't worry about ampersand, it means getting the reference, so it means we won't be discussing about the ownership and reverse. We discuss it previously now so now we won't be discussing about this, so this is just a reference. You will take a reference of energy and return. This.

A

And then so now, instead of instead of impl yin, we can say impl energy for yin, so the we are implementing this trade energy. We are. We are implementing this trade energy for yin, so we need to put in all the items all the methods within energy. So if you see I'm pl something it mean for something, it means that uh the the item will contain all the methods within this trade. So in this case it have is like, and it will have also is one I'll say I simplify.

A

I just show one of them, but I need to have all of them, and then we notice that the press action will also break due to self but yeah. That's not that's, not important, and then so now we will change instead of writing it. Previously, we we put in the currently you'll notice.

A

Just now, we need to pass in two parameter, but in this case we just pass in energy and then something that implements this energy because it implements the trait so so, because yin implements the energy yeah because it implements the energy, so you can call directly. You can call energy dot is like waiting here, because the energy is energy is here and is within the within the crate, so you can call it. So this is how how you want to guarantee that something how you want to do the shared behavior.

A

So you, if you, if you have multiple items that have the same behavior you can implement, you can implement it as a trade, but sometimes you also one need to split into multiple trades. So a single item could have different behavior because things change. Sometimes you need to create new trades yeah. So this is trades.

A

Is there any question up to you here.

A

Okay, there's no question, then: let's continue to the next slide. So now we will be talking about extension. Trade, but and russ only allows the inherent methods to be defined on the type where the type is defined.

A

Same goes for the same goals for the trait.

A

What this means is that.

A

Hey right here: okay, let's ignore this first, okay, if you want to extend the third part extended party trade with more methods: okay, okay, okay, I understand this now yeah, so so this means that if your type is inside a crate creates like a library in rus and then you can only implement.

A

You can only implement the methods for that type within the crate that you own, you can't do it for other people like you, you cannot just go in and modify other people called like monkey patching or something like that. You can't you can't do that because, like if someone, if you, if you have a library, someone just patched another library for you, then that will be very confusing so nice. Does it allow that so the trade you can already change within your trade stuff?

A

You can only change the stuff within your own crate, but what if you want to extend the third party third party, create stuff to third parties, trade with more methods?

A

Let's say you have, uh let's see right as the iterator trade yeah, you want to extend it more stuff. Also. This is also known, as extension, trade, to extend another trade. For example. We want to extend the full trade from full credit. You see here. We have another call fool, so we will import this function. We use it.

A

So this is a crate. Full is a crate, and so now we define another. So we define this called full ext. This is a convention in russ, it's a it's a created in rfc, but people don't have follow this. It's just a convention. Russ doesn't guarantee that this must be ext.

A

So you want to extend you want to accept this full trade. So you you adding another fn fn bar, then self. So now so now you can so now you get. No food is now great here.

A

Okay, sorry, sorry, please, now trade with a truck, so you can implement. You can implement the extension you just define in your crate to that, to to the struct and and then, when you, when you use the full right, you can use the full inside the other module inside the other file. You have. You can just use this, so you import full ext and then you can start using the new new items.

A

You can start using the new methods within that trade that you imported. So if you have full here, you can use the fm bar, so this is called extension extension trades. You extend the third party stuff, extend you use a trade to extend third party third party stuff.

A

Any question I'll do here.

A

A

Hello, okay, is it better now.

A

Okay, nevermind: let's I continue. I increased my volume already now, so the next is default implementation from the previous energy example. We only see the methods define the implementation, so we only see just now. We only see it matters in the information, but now, but what if we want to have a helper in a trades that depends on another method.

A

Just like you see like the we have one function and two function, but the function will depend on each other.

A

So this example we will have a function depends on each other. We will see, but I'll give you the rough one. First, it's not the so we now we have a trade called jumpable and there are two methods: one is called jump and then one is called double jump, so we have a struct homo, sapien, homosexual and basically human scientific term. So we have got a name.

A

So now we want to implement the trait for when to implement a trait for homo sapien.

A

Let's then, we create the first function, jump and then you'll print I jump. But then you want to do another function, double jump, then you, basically you want to run the same function twice right. Then you just run it twice, but yeah you just imagine. If we have 10 strap, then we need to do this 10 times you do a double jump, double jump, double jump and then inside double jump. We need to run the self.jump twice.

A

Just imagine we keep doing this many times so it will be, it will be very I'll, say very non-agronomic.

A

So that's why we got default. Implementation and default. Implementation means that inside a trade we just call another function in a trade. So in this case you will see that this is the default. The how this is like the default way, the trade behave. If you don't define it.

A

This is mainly used a lot in the in the rust iterator.

A

A

Let me switch a bit.

A

Okay, so we see here okay, so we open up the documentation, so this is used a lot in here.

A

So you see, this is the last class iterator documentation and then, if you see look at the methods- and you see a lot of it is implemented, this is this required methods basically means that that's the only required method that you need to implement. There are many other methods you see. There are many other methods, but you see that they have a default implementation. Only this one, you implement one thing that everything else is done for you.

A

So this is the power of default implementation.

A

And let's switch it yeah, so the default implementation- you just do this here and there you can call the other stuff you define in the same trade. Basically you'll do this and then you'll define the struct. You just implement you just implement. When you implement jumpable, you just implement a jump, then you don't need to implement the double jump. Then you can you can you can use the, but in other in when you, when you do homozygous, then you can just run double jump like normal and then, when you run double jump you do this.

A

Of course you can. You can still override manually. You want to you want to change this to what you want. Also, can then you don't, it will not use the default. So this is the default implementation for trade.

A

Okay. Until now any question.

A

Next is a trade balance, so trade down is a bit more harder to understand compared to just the plain trades. So we need to understand, but trade balance requires some knowledge in generic, so we need to first explain the generics.

A

Why is generics so some people that some some people some participants may not be familiar with? If you don't use the some of the type language so I'll explain? Well, the quick generics recap like why generics exist.

A

Let's say we have a function that returns one item or the other, so we have uh when we have function called rand. Basically, it is not ran it's random. It's not random enough. It's just true, but the first part first argument is the x. Is your size, your size is us in russ means unsigned in unsigned integer, but of the machine size this basically like uh uint and c the unsigned integer size, but based on your machine. So if your machine is 64 bit, you'll get a 60 you'll get a 64 bit in heat.

A

If you guess this is a 4-bit unsigned, integer assign integer basically means that your integer cannot be cannot be negative. So they see and then you've got two parameter so two of them you return one of them.

A

Okay, now understand this return, it returns one of them, but what? If we need another version and different type? So now we have a string and then we have another string, but you'll notice that it has the same. It has the same function name.

A

Oh then, oh then you'll get a compiler error. Progress will error, but this should be colored, but the compiler will color you, but I don't have color here here. Correct, also error, because the same function is defined twice.

A

You see, as I will say, the rand is defined multiple times first time in line one and second time in line nine see it's same function, but it said you have a different value, but this this one russ didn't give a good start with a good suggestion to say, or you need to use the direct idiom, how idioms, because yeah you can just use generic and then people and then in link in languages that don't have generics, but first they want to do it in lyrics.

A

But people should do something like that, so people will do like templating, so we'll copy copy the code and then paste it one version and then copy the code and then we'll share and place another version. And then this one will be uh so people prefix this with issue. What what people do for the language they don't have generis. So they will just do another function themselves. They'll manually duplicate the code and do this.

A

But I also have quite a bit, but this you'll save the it will save the number of typing user people have. But but in this way it's more explicit, you know, you know what function will be there.

A

So basically you have two functions. Then this one, this one will compile now because you have two different function name.

A

So basically, generics hit is to do this, so you can say for ran for anything. The type t, so you have a generic of type t and then so x is of type key and y is of type t, and it return. Type t means that your argument, the first argument type and the second argument type- must be the same as the return type in this case.

A

So basically you see you save the code from from this to this, so this is for the generics.

A

Okay. Let's now, let's get back to uh trade down, so we learned about the generics and why generics is required.

B

A

Wait, I'm still showing my browser.

A

I already shipped my terminal no.

A

Okay, let me stop.

A

Okay, let's, let's go back and yeah I'm I switch okay, let's go back so talk, go back to travis, just that! That's generics.

A

We learned about generic, so there's a function called rand.

A

So when takes in the first arguments you sizes are explained, your size is unsigned integer of. If the machine size extra me your size, then it returns one of them, so it returns well there. So it basically returns your size and.

A

And then so we have we need to have another version, but we we have a parameter string. Second parameter is also string, so it returns one of them. But if we do, if we have both of these together, then we will see an error because they are the same function. Name.

A

So people start doing this, people duplicate the function name and then add add stuff to the function name, so it will start compiling because the function name is different and people for different type people use different function and generics we can with generics. We can do this, we can just run. We can just have a same one function, but it can. It can do multiple items.

A

Okay, let's get back to trade balance, so we learned about generics and now the we have a trade imper, because we just now we learn about the trade in parameter. We we won't work like if you want to do the same example just now. This one won't work here, because if we do something that implements a trade call for- and we have another thing that implements a trade called foo, but we return something called foo.

A

This won't compile because because it could be different, like your ex could be bar, like, let's say bar and bus in implement 4.

A

So your first argument could be bar and second argument could be bus and it returns a different one. So russ doesn't allow it to com compile because it must be the same. It must know what is the type beforehand, but this will work just that you cannot.

A

This will work, but it might not be the behavior you want, because what we want is we want the first argument and second argument to have to be of the same type, and the return type should also be the same type.

A

And and then so what if we we need generics, but we still want to limit the item.

A

So so this is for trade bounce. It means that it's a generic, but it is bounded by the trade. So we, let's take back. The previous example run, but in this case we put the full trade here so means that the for the type reading here for the type key it must implement the full trade.

A

So for this you can guarantee that the function implements the full trade so inside here you can use the you can use whatever method defined in full, so you can like, let's say four, have a dot bar, so you can use dot bar here the bar method. You can also do more generic. You can also add more stuff here like this, or you can also depend. You can also make one generic.

A

You can also make one generic depend on another one. The same method is also used to define lifetime, but I won't talk about lifetime now.

A

And this will guarantee that uh yeah. You know you're guaranteed that everything inside here implements the impairments full.

A

Okay, but, and if not, if we need more restriction, we can always make the can always make it stricter, so so for t now it needs to implement both full and implement or, but if you want to do the thing we want to do previously, you can also do like these are implement input.

A

But so we discussed about the trade balance basically used for generics. You can define the behavior of the generic.

A

And now, let's talk about super trade.

A

So superhero is sort of an inheritance for trade, but- and so let's say what, if you want to have a trade that depends on another trade, let's say we want to have a bar to depends on full.

A

No, we want to have bar bus to run full twice. The trade.

A

Okay, now this is outdated but yeah. Basically, we have an example. Here we have a trade call runnable which, which means that anything in payments runnable can run, can have a method call run, and then we also have another trade called naruto runnable.

A

Of course we can also put a pass here. We can do what we learned previously. We can do the task, so it means that it implements multiple item here but yeah. I just show this for now.

A

So this is a super trade. This trade must implement so to to have this trade to implement this trade. You must implement this trade. So if something, if you are something that have this trade, so you know that it is.

A

You also have this item and and then another variable have a method called autorun, so it will run yeah with the with the hands behind two hands behind like one and I will go then so now we create another functional goal and it is that takes in a parameter, the agreement, human, the implements now auto runnable. So you basically have this auto run here now we do the same. We have a struct naruto how how to how to have something that is this.

A

To have this, we need to implement runnable for naruto. You notice. We don't need anything here, because we already do a default here. That does nothing and we implement now to run also but yeah. If you don't implement this, then russ have an error saying that you can't you can't implement this for another because it doesn't implement this. So it's like a dependency to get this. You might. You must have this.

A

This is use for what you call. This is used for the this there's a rash trick called copy and there's two straight copy and cone from what I remember. The the copy will have stuff in code as well. So copy is a super trade of code. If put more, you can put more stuff here so because this is here to type it up.

A

So n is h, so the message takes in two node.

A

And and then it has actually returned a boolean, so it checks these two nodes and a return boolean.

A

But if you want to use it is it's quite inconvenient because we, if you got to do generics for it, it's quite inconvenient, because we need to write out like so many types you do so many g right here, like we want to do g is graph and e. Yes, these two needs to be the same. You see the n needs to be the same.

A

So when you pass in n here and then an energy, you need to put the n here and e here, because this is because this is how the graph is defined. So every time we use we every time we use the generate here, we need to specify every time you use graphene, you specify n and e.

A

So you specify this, and if we we can't, we can't just put n here because it won't like, because you can't have it hanging by itself. So you need to define n here as well, so we need to define, there's a j right, called n and a general called e and, and that is j and then there's a g which is which, which is bounded by remember this, is a trade bound. The j is bounded by graph with parameter n is the first generate here.

A

N and e is the second generator here e and you'll notice. It's quite it'll, get a bit more you'll get harder to rate, as this goes on so the first, so the first parameter for this distance is graph which is taking a reference of g, which is a graph. Second parameter is n. The start. N is also node, so you can see here. The n all is the same, always the same same type yeah. This also take a reference start and end as well, so it will return.

A

This this is wrong. It is outdated. I took this from the so this from an older rfc, probably the uint previously, but the changes in size. I think this is like this older rfc and so here then then they introduce associated types.

A

It means that the we have now we have an item. We have a type that is associated to the trade see so the graph will always have a type n and will always have a type e but yeah. Now we now we lose the now we lose the j ray. This is no longer generic, because now one graph is only, it must be associated with only one type and one type node, one node type and one edge type.

A

So you can't do if you want to use the if you want to implement the graph for something the you can only implement one graph now and if you implement one graph, then you can have the n and e here as specified when during implement. So when you implement you just need to put out the type n equals to what you want, what the type you want to be.

A

Then this n is taking from here the this n is taking for the j array, and here it can be any type you specified here later when you implement, when you implement you specify the type.

A

So when you implement you just specify the type so now the n and e is associated to graph g. This is more readable when you.

A

So for the same function distance, then there is a g which is the uh graph. Is the trick bound g here? So you see we have no more n and e. This is easier to type out also and here to read, and then you have the graph, which is the same as previous g.

A

But now start you just say that g. The item end within g, so this basically refers to and then the n is the same. So this is associated type. It means that the type is associated to that trade.

A

It just it just specified the behavior, it's not it's not like you just may spread the type. Only it's not. It is not containing a data. Just a type.

A

And- and there are also defaults with the you- can also do defaults. Basically, you you see just now. If you want, if you want the type to have a default, then you can always put equal to some default, but I won't show that now and- and you can also you can also do- you can also do generic.

A

A

Someone say anything.

A

Okay, never mind so and then there's also git generic associated type, but this is not fully stabilized, there's only part of it.

A

So, as you can see, this is an example of git. There's a live, so we have a type, but this type now have a generic. It's not possible. Now, I'm not sure whether it is possible, but the jlt is partially stabilized, so not all of the stuff within the generic associated type can be can be done before I recall, so what it looks like you can specify. uh Basically, this is a lifetime.

A

How you specify lifetime in rust, but I won't talk about lifetime here last time is basically how how long how long a variable leave like the like, basically a lifetime of the type, but here you can just think of it as a normal n like a normal g right here, you can just think of it right, but here in the example the gif is like, so you can just think of this t type key and type t.

A

So this is the worst case of streaming generator.

A

Within the associated type, so we have discussed generic okay. We have discussed generic type so where we add the generics to the trade and we also discuss associated type, then some people might get confused like. Oh, there are two methods we can do. The we can do the same trade.

A

So when do we use one or the other, and if you see associated types are used like when there's only one impl, let's say: there's an iterator, the trade iterator. This is in raw standard library, so iterator this so iterator is the trick to the a trick to say how how the structure will iterate over something.

A

So in this case you have a type item. So this type item means that when you call next on the iterator so means you get next item on the iterator here. We turn you this item, so you, as you can see, iterator can only have exactly one item type. Otherwise it will be confusing, like you have the same iterator. But then, when you get the next value, you suddenly get a different iterator. That's why it is implemented as associated type and not generate time.

A

So it cannot be generic because you want to you want to have exactly one item like when you iterate a word when you iterate over a string, you want to iterate over each character's of within a string. Then you get what character first, character, second character: the character not like you get first character, then suddenly, the next item you get one bite, then it will be confusing.

A

So this is only must be one single type for the trade iterator and from from the right. I also take another example. So when is generate types used, so general type is used when there are multiple types are needed.

A

Let's say unless there's a trade call from iterator.

A

It means that this this this thing can be derived from an iterator of the generic a so you can. You can have uh so you can have from from iterator where the key is the generic and then there's about. Basically, the right here is similar to the trade down you see just now. Just that is it's a bit. It's a different syntax and you can put more stuff within here. You can like go next line next line with a different with a different trick bound.

A

Otherwise you have everything put in one one of these one, one, this one and then you'll make it very long. So this will make it clearer.

A

So we also have another example borrow which is easier to understand, but I showed this example, because we- because we have never seen this so what this formulator does is it will take in and you have general a, and here we have something that have iterator with. uh So if, for anything, this t is anything that implements into iterator with the associated type of item is a so for this. Basically, it means that anything that have that implements the into a iterator internal function. It is just basically doing the reverse.

A

It just reversing the into iterator but yeah for those that that it's not very familiar express the into iterator. Is you you can make something an iterator, because this is iterator, but integrator is something that you can it's a trade that say you can you can convert that you can convert that item. You have the struct or enum or something and convert it into an iterator. That's basically it and from iterator is similar. You just convert it back.

A

But you also know that it can be mixed. You can also mix two you can. You can also use both associated type and generic together.

A

So we have a add trade in us.

A

So there's a trade called ad. It was there's, add trade because, like uh you can you can you can have? Let's say you have custom type, you can just implement the add trade. Then you can add two custom type together. Let's say you have uh you have a duration, you have a type duration type and you have another duration type. Then you can add them together. Then it will become a duration type.

A

So in this case you see the trade at.

A

With the rss, basically is, the is the first generic here. Self itself means that by default, the type is the same as the the same as itself. Basically, let me let me show example.

A

Let's say: let's say you have a duration structure, I'll show the stuff inside, but you can you can do you can do the you can implement the you can implement this add.

A

A

And let me check it out.

A

Yeah, you can do this, you can implement add for duration.

A

Then you want to have type output.

A

If you add duration with duration, what will be, what will it appear?

A

It will appear as okay, let's, let's not use duration as a first example. Let's use uh take time so.

B

Yeah, so I I don't need the.

A

Values here so yeah for date, time.

A

Okay, no, no use duration, confusion. You can't really add a time state time so you'll add duration. By default. You see just now. We have a self here and basically this means duration by default. But we don't have to receive this because that's a default value default to this, so it defaults to iteration and then the and then the function, the output, if we add direction with duration or we become, it will become a duration and we have add function. We must implement this.

A

So it add so you'll notice. Here it doesn't have this thing because it is it's not taking by reference. It takes the whole value and use that value. So the way it's gone.

A

So the right hand side is uh right hand. Side is.

A

Basically, the same thing: okay, you can do duration here. Let's do this for now.

A

But yeah here we can always you can always do this.

A

You can always change this yourself, because itself means that it will get the it will get itself because self mist is duration, but it's the same. I use this for to make it clearer. So with this you can.

A

If you have this, then you can have a duration.

A

You can let let's say you have the start: no duration, a and duration b.

A

And you can duration a at with derivative and b.

A

You can do this, so it is adding a duration iteration, but what's the generics for like. Why is this generic? So what we can do here is. We can have take time notice that.

A

Yeah I'll stop the position a bit, but yeah just ignore that at date, time.

A

For duration, so you can do this. This will work because it's a different trade by default is a duration, so you'll notice that these two different trade it work because it implements two different stuff, one is add size. Add duration y is at date time, so the type output the output should be that time because, once you add the duration, it will be another time. Also.

A

A

So basically, here you have a right hand side. You have date time, because this is here. It's mentioned here see s here is here, so the output is update time.

A

So, once you add a duration with another time, it will become a date time. So what you can do here is, you can have a date time.

A

Let's say you have a division, a and a date time b.

A

And then so now you can have you can do this duration, a plus the time b? This should work with if this implementation, but yeah you can't you can't do this, you can't do you can't do with that. You can't do that time, b, plus duration, a you can't do because, because you add the right hand, side mass, the duration, you add to right hand. Side must be that time.

A

You see the duration that right hand. Side must be that time. So, if your right hand side is, if you are you flip, it means you are wrong already. Then you will work.

A

So it is basically like how how you can mix both the generic and associated type.

A

And next is the I've discussed most of the stuff and now we'll talk about some concerns with and the results the trade with trade. So so there are like issues with trade and and then based on this issue. People also do some designs and the design is slightly different.

A

So one thing is auto derived and ambiguity. It's a bit. It's very hard harder to understand this, but auto delivery is basically like rust, automatically figure out what type you want you infer what type you want.

A

So if you have a, if you have let's say if you have type a or figure or you you might want type b.

A

So, although draft is this, so does ambiguity, let's say you have a trade pilot called fly and then you have another trade wizard also have a method called method fly. Now we have a strong human so for human, your impairment pilot and your impairment. Wizard, you see, there's only there's only fly here.

A

A

And then you notice that and then you notice that the fly here so one is right. Pilot for humans say hey, this is your captain speaking and the wizard say up so both is the both have the same function.

A

So if, if you implement the human and then you also implement the human there's, a function called fly and it's waving yeah just print here waving. I'm furiously.

A

And then so, okay, then the the compiler have error, so russ doesn't know which trade to and and then it says,.

A

So so this says type annotation needed because they you have a when you print a baby dot animal baby name, so you're called wait. Why is this a different example?

A

Yeah? It is same name. Basically, you just call the same thing just this is a different example and we have two things that implements the.

A

You have two things that implement the same thing notice here in this case, when you call fly, if you have a human, when you call fly rust, doesn't know which- which one which one are you calling pilot or are you calling wizard, because you have both functions like so residual, but this is a different example.

A

The array is similar to this. So.

A

Okay, now it works this time. Okay, thank you, yeah, so, basically the compiler bomb already. Then, then you to solve it now we need to use something called fully qualified syntax.

A

Now you have a you need to do this type as type as trade and the function. So oh, this is also. This is the same example of the area. One basically you have you have uh this. This is a dog as animal, so the animal is the animal. Is the trait.

A

Now you are using the you are using the type called the type is not as animal, so you run the animal animal within the type. So you run this baby name, so you can you can you can know okay which a which trade within that type is being used to to specify exactly which one? Because you can only because one one type can only implement one one trade at one time and and yeah there's quite a lot. I think.

A

And the next is coherence, so it's discussed in one of previous talks. Basically, it means that there is at most one implementation of a trade for any given type.

A

For example, you, where there's a so it's a red, popular rust library for serialization and serialization, basically do the json, yamo jason csv those kind. This kind of commotion are converted to a serious serialized format. Some other languages call it.

A

I call it marshalling thing.

A

So there's a series is a trade and you have another crate. You have a duration there, so this both of this is not your crate. So you can't do this because this, like it's not allowing offering rule you can't you can't just like, like I mentioned before, you can't just implement a trade for other people. Other people's stuff, like you, can't just randomly, go and implement this when other people's stuff.

A

If, let's say there are like multiple crates and then different people are going randomly quite implement the same trade for the type that you put here when they break, then it's like suddenly, it will be very surprising for other people hey how come how come when I, when I add another comment at the grid to when I add another grade to use like basically use another library, that's a very uh existing code break so yeah, rather than allow that. So you can't really do this due to orphan rule.

A

So one way to solve this, so this whole thing is called coherence. Almost one thing also called offer rule, and so one way to do this is to pick it. The original strike into one's own credit, like basically.

A

And last thing is the model confusion. You notice that the the trades just now we see it's important as the like normal cut normal types today, I'm also confident. Oh four, is it four? Is it a trade or four? Is it? uh Is it a straw? Is it a trait or an im?

A

Just it could be any of them, but so usually, for these people number two is people usually put it as like action. I say serializable, sort of an action or something or add or like it's a iterator sort of action, not like this now thing.

A

So this is a normal use. You normally import your import from standard library, fs the file system, it's a it's a normal struct and, and then you use you use the standard. Io output, the buffer, the buffer, is the buffer, which means that the radar is uh there's a buffer for it. So you don't need to you. It's that it's back by the memory, so you don't need to like keep. Keep issuing the system call and then there's also wait. Wait is a trade, so you notice here.

A

It's not noticeable like buffet is a type and rate is a trade, and if you didn't include the trade here, this function will compile, because you need the red crate to be able to run the function rate. This is an extension trade because you will put the you put this function in scope.

A

If you don't have this rate, then you can't do this, you can't run you can't run the you can't run the methods within the. So that's why I say the first thing I say is: it needs to be in scope, so you'll wrap the buffer new. You open the file and put it around the buffer reader.

A

Then you have a buffer. This is basically an array of ten zeros. It will it's just bootable. You can change the f.rate, you open the file and you wait into the buffer here right into the buffer.

A

uh Can you do this for now? This is this means uh mutable reference like the pass in as a reference, but can be, can be mutated. Rotated means you can change the way, change the value and the question mark basically means the error handling rust. You can you property out, so pretty I will ensure it will print out the bikes.

A

It will print out the bikes within the buffer. So basically you see this. So if the trade is not here and you notice, it's not you can't the people say this call no graph ability, you can't you can't grab for the rate.

A

Search file you can find file here, you search pathfinder, you can find buffer, but you search rate. Oh, you cannot find any rate and what is this yeah? So if you, if you remove it, then oh this will break yeah, there's no graphic probability or you. You can just use this predict. But if you do the star, you don't know why it's in the star.

A

So we should remove this preview. Then oh, this will break yeah. So this is uh some sort of composition that I noticed so. Okay, the end any question.

A

Any question regarding crates or anyone to see any examples can ask questions.

A

A

A

Do you have any questions should should we end.

A

If, if there's any question yeah, I can just open the bike and ask once four sides: I already increased.

A

A

Hopefully, you all can understand so the for the rest meet up. We will have it every every two months and usually there will be a topic and anyone can give anyone can give the rest talk and yeah speakers are welcome.

A

And then thanks thanks a lot for joining you're up to you to see, and if your one can ask question like: can us like show a demo or something but yeah this time? I didn't. I didn't do a demo, so, okay, thanks a lot aaron for joining yeah can can end the screen and end the stream. Now.