Rust Programming Language Rust Cologne, 6 Sep 2018

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Rust Cologne: A generalist's view of traits

Description

https://media.ccc.de/v/rustcologne.2018.09.generalists-view-traits

People coming from other languages can find a lot of familiar aspects in Rust’s traits:
Traits are somewhat like interfaces, and also somewhat like type classes, and also like… classes?
This talk will try to give you an overview of what traits are and how you can use them to make your code more concise and flexible.

Pascal Hertleif

A

All right tonight we'll talk about trades and my talk will be about strength traits from the ground up so basics, on trade and what the difference between traits interfaces is, for example, and how you can use trades to write very abstract and generic code in rust.

A

My name is Pascal and these days I do web development related stuff, but also rust, and one of the co-organizers. A serious cologne and my handle on various places on the internet is killer cup and if you want to read some rambling about some stuffs, that also often includes rust, go-to deterministic, dot space first off a warning through these slides together and all I could come up with this code, so lots of code, but also please please please interrupt me when you have questions as Florian just mentioned.

A

There's a microphone just raise your hand and he'll bring it to you, and we have your questions on video.

A

Please use the mic, so why are we even talking about rates? Let's first take a step back and talk about what you're even doing when we are programming and most of the time the things we are doing is dealing with data and doing some stuff with it. So let's do some stuff with us. So this example I hope you can all read it is a function called make true. It takes as input parameter, string slice and gives you back a string, and how do you make stuff true?

A

Do you shout them, obviously, by adding exclamation marks? That's yet okay, so this is good. We can now make string. Slice is true, and this is a very useful function, because we have string slices in many various forms, but also we maybe want to represent our data in a more domain-specific way. For example, if we are actually dealing with facts, we may not want to take a string slice, but a reference to affect this fact is indeed justice structure, which has one field context, and it is a string.

A

The function body is exactly the same. The only difference is that we are now returning a fact. Instead of just returning the string nice, we thought I was out of the way, let's actually add some behavior to the data itself and not just as a free-standing function outside of it.

A

How did you add data behavior to data well in most programming language? There's the concept, that's called a method and you may be asking: how do you write a method in rust? The answer is rather simple: you write input and the name of your data type open, curly brackets, and then you write some function, maybe copy paste in the function. You just saw on the slide before this one and close parentheses.

A

Now our example looks like this and what we have a message we now can use this method to give an effect call make through on it and get back the true fact.

A

Let me go back one slide. Oh.

A

What is self you may be asking, and indeed self is something we did not have before before we had some input parameter of the type, and this is the most obvious difference between methods and functions methods operate on the data.

A

You actually are decorating, you can access this data using a form of self as first parameter self is very explicitly set in rust and not implicitly given by a keyword like this, as in JavaScript or Java, for example- and you may be wondering- am form of self yes form of self, because in rust you actually have to annotate, which kind of self do you want? Do you want a reference to self that you can only read?

A

Do you want to have a mutable reference to self, or do you maybe want to get self or mutt selves as a mutable self and take ownership of self? Don't worry it's the only version that can actually takes the data and destroy it. The other ones can only read or manipulate it.

A

Okay, let's look at another implementation of make true. So here we take the mutable reference to our effect and we don't generate a new string to put in a new effect. We actually just change our effect, so it's now an alternate effect or something and the natural implementation would be to take this fact as in itself, without taking a reference and returning it in a change form. What's the difference that you can no longer use original effects you put into this okay, now we've covered data and how we can add behavior to it.

A

But I mentions, as this talk was actually what writes and you may be asking assistance right and yes, it is, but it doesn't have a name and we can give it a name. We can call the straight truth and write this a function, signature or the method signature in this case it is in this case reference to self, as we saw on the first example and return something some self. Okay, we'll come back to this.

A

Let's implement it first same thing: we did above, except for the first line where we say imple truce, for fact, and not just imperfect, and indeed you can implement the strike for basically everything if you wanted to, for example, for integers, we could make integers true if that makes sense to you.

A

Why are we even doing this? What what's the advantage of writing traits instead of just adding methods to datatypes?

A

Well, the most obvious one is that we now can name these concepts and we can share as a behavior between different data types and also we can abstract over this behavior and the way we do this is by writing a implementation like this. This is a function called print news and as an input parameter, it takes a reference to a slice of tea like some list that contains T's. But what is T t is just a placeholder, the type parameter, and it has some constraints on it.

A

As you can see, right after the function name in the angular brackets t, : truce means we have some placeholder called T and we need any type of data that implements the trade truce we've just written so function. We can do some stuff with this facts list and we can at least make them true, because we know any type in this list implements truth, but actually, if you look at it, this does not compile, because we are not only making facts. True, we also printing them and indeed Russ, see the Russ compiler tells us.

A

T does not implement standard format display, because we have no idea how to actually display facts. This error message is actually quite explicit about it. He cannot be former that was it default formatter. It has some helpful ideas like, for example, at the trade display is not implemented and that we can do other stuff with it, but also that it is required by format and format is actually some things. Print macro calls internally, that's all good, but why?

A

Okay? What do you actually know about this T? We know that it implements truth and well. Actually, that's it. That's basically it I'm sorry person after Excel ask me later. If you want to have the discussion about automatically implemented traits, but basically all we know, we said T implementers.

A

If you also wants to print it, we need to add another implementation, and indeed we can just say so, like we can import standard from it, the module that contains the display, crate. Let's write and say: ok, our team needs to implement truth and also display this works, assuming that, given our example copy form, we also add this implementation of another traits.

A

It's comes from the standard library display and tell the compiler what to actually do when we print these, you don't actually to rhesus is just we can implement traits that someone else has written and they are great, for example, the standard library and implement them for our data types as well, not just other way around and you need here we go it's the main function, calling print news on the list effects and yes, we've just printed to news.

A

Interesting fact: if we go back to this, the T Colin truths plus format display. Yes, many not the most interesting information you have in this particularly a place right after the function. Signature. So there's another way of writing it, and this is where of syntax. You can write T, :, throughs and display right after the function name also, you can write just the T after the function name and then after the function, signature put aware and say: trues plus display. Just so you don't get confused. This is absolutely equivalent syntax.

A

By the way, talking of syntax, we can also add placeholders in other places, for example in our implementation block. We can say: okay, we want to implement this trait for this type, but with the placeholder in the type as well like this implementation block is valid for all vectors, where the items implements a debug, trait and debug is basically as a machine, readable version or the human debuggable version of the display crate right.

A

Okay, this, basically all you need to know if you want to write methods in traits and implement them for your types, but you can also implement other stuff. You can add other things to your traits and we just need to take one more step back and talk about. What even is that's right. It writes the connection of associated items. It's the most basic one associated functions is what we've seen all along its methods, but Sarah also associated types. So consider this example.

A

There are some iterators right and all you need to do to implement an iterator is to provide the next function. There are way more functions on iterators and I'm showing here, but next is the most important one and litterateur works like this. Do you have something that wraps your data and if you call the iterators next function on it, you get a new value like from your data from your list, for example, where you have a vector of integers and you get the next one, for example, to implement a for loop.

A

And now you need to say what is next return.

A

We implement our trade on a vector and vector is kind of generic over the content, so you might say: okay, whatever is in my vector. This is the type of item I get from my next function.

A

But if you write an implementation for NASA datatype, that may not be generic, you can't just look at the signature of the datatype and say: hmm okay. Obviously, this has to be also a T, because there is no T so with associated types. You can specify what you want to call this type that you want to return, because this type is not a generic type over your data, it's the generic type that it becomes concrete in your implementation block.

A

So, for example, if I have a data type called for integers, that gives me you guessed it for integers. My return type is an integer if I had the data type that contains the file and they won't read lines from it. My return tab in this iterator would be string, for example, so associated types is a way to give a name, and also in the iterator different sorry I'm in the trait definition. To give the constraints these types need to fulfill.

A

For example, I could say: I have a debuggable iterator, and my item type needs to implement debug.

A

This is associated items, there's one more item. We can cover it's kind of in each case, but I'm just showing it associated constants. For example, if you have a super lock trait and you want to prefix each lock message with a specific string that is specific to your type, but you don't want to have a message that always returns the type name. You can write a constant, so this is just a constant set lives alongside your straight implementation.

A

A good example from the standard library is that you have the type that is implemented for numbers, and if you want to be very generic over multiplication, you need to have two constants identity element and whatever the other one is called, the one is the first one is one and the other one is zero, but you don't know which type it has, because you are writing it, saying that it's generic over type.

A

So in the implementation for floating-point numbers, you can say okay for F 64 is this is a constant, zero floating 164 and in floating-point with 32 bits, precision you're right! This is a zero with 32-bits, precision, okay and so fine.

A

There are other interesting things you need to know about traits to really get started. For example, say you write a trait and you have a function. That's called clone. You might not know this, but the standard library also has a trade with a function called clone. What do you do if you use the regular syntax of my name? Dot clone? You have no idea which message you're actually calling.

A

So there is a syntax to specify which trait you actually want to call, and it's angular brackets my data type as the trait I want to treat it as colon colon method name. You can also write in this case truths. Colon colon make true, because you know that I'm only supplying one parameter effect, which determines that. Actually, my implementation, for fact, is going to be called. Yes, please go ahead.

A

B

It would be actually most well traits with famous as implemented on one datatype. Would they be like default method that will be called? I would just be a compile time error if you call it as two regular syntax, so you're also always required to use the special syntax in that case or what would happen very.

A

Good question: I actually don't know the answer to it. We can try to find out later. I think you get a compiler error if it's very unambiguous, but if you use glop imports there may be some other rules happening. We can try it later like. This is very interesting question. Actually.

A

All right, one area we haven't covered yet is what traits are also used for that. You may not know, because if you write one plus two actually it expands to an implementation of the ad. It's right that isn't the standard operators module. The at trade is very simple. It actually only gives you an ADD method, but this also means that you can write your own implementation of ad.

A

If you wanted to like, if you have a hash set and adding two hash sets together makes sense to you or if you wanted to be totally insane and write an implementation for divided for pass, for example, so you can write a /b and get it concatenated.

A

Please, please don't do this, but this is just my opinion.

A

Another interesting edge case, it's right that has basically no content whatsoever and it's still useful. These are called market rates and you can use them to, as a name suggests, mark stuff, for example, if you wanted to say you only care about the specific set of types that all happen to implement this play, but also needed to be fancy.

A

For some reason, you can write the fancy trade that has no masses, no types, no constants and just implement them for your types, and then you can write a constraint that is T where this T implements this play and fancy.

A

This may sound weird at first, but it's actually how rust implements the notion of sender, bill and syncable types. If you wanted to use a specific data type in multiple threads, the compiler might give you a message like now. You can do this because this type doesn't implement send, or this type doesn't implement. Sync, these traits do nothing but require you to say this type is actually send able across threads, because a compiler can't prove that this type actually is sandable over threats. To give it a marker.

A

All right, that's all I have and thank you very much for listening. If you have any questions, please go ahead.

A

C

Traced like, for example, drop primitives in the language, are they implemented within the standard library? Do you know that, oh this.

A

Is also a very good question: I don't have a precise answer, I'm fairly certain that they are implemented in the core library and marked as language items, so you can go either way and say: ok, this is actually a like language specific, but also it's in the core library and I could replace it, I'm, not sure for drop. But for many other things there are flagged as language items.

D

Yeah, if I have a generic implementation of a trade and I want to specialize this for one type, how would I do that so can I just give a special implementation? Oh you're.

A

Only asking questions: I, don't have to precise answer to you and now there is a feature called specialization that is not yet stabilized, but I think there is some part that is already possible.

A

So maybe- or maybe only this- is this a feature flag but very good question because I haven't covers this, you can implement generic implementations of traits. You can say, implement this randoms right, I just wrote for every type T that implements display. For example, good point.

E

Thank you, so you had this example of the trade where you had a function that returns a self. Yes, um this looks kind of like a generic, so where's the difference between this and a trade generic.

E

A

To find it yeah real quick, it.

E

Was pretty much at the beginning, I think I think.

A

So too, but forgot about it.

A

Here it is okay, it's not a generic per se, but it is.

A

Some kind of placeholder for the type you're actually implementing your trade form in this case you know it's a 32 in a more generic case. You don't know, what's the type actually yes and in our trade definition, you also don't know yeah, you don't know what type you're implement what type your implementation is currently trying to deal with, but you don't want to.

A

You need to need a way to actually say I want to return. The same thing. I got basically and upper case. Self is the type you're implementing from, but.

E

That's what I imagine what a generic is? Isn't it I am I'm from C++, and this looks like templates function, you.

A

E

A

An implicit generic you.

E

Could say: okay, yeah, you.

A

The generic type parameter is something like this tea, but our self, this itself is not explicitly named. It's always the type we are implementing for. If.

C

B

You basically just use the function and open an open heart and it will t be there. He wouldn't.

A

Have any concepts in air landed in the language.

A

Someone added that in C++ this might be covered by concepts, but not by templates themselves.

E

Would be the difference between descent but I? Think I kinda understood.

E

Just yes, I think for me: I answered okay, since you can parameterize traits. What's the point of Associated types.

A

What, if you want to parameterize a trait but only ever implemented for one specific return? Tab like if iterator was generic over its return types? You could write multiple implementations of iterator for vector ax, for example, but using Associated types which are not parameterised themselves in the implementation and signature. You can only ever provide one implementation of iterator for a vector, it's an additional constraint. Basically, if that makes sense, I.

E

Think I need to think about that a little bit. Okay, I.

B

Actually have not a question: there's no concept, I or one thing: I've kind of been struggling, we're supposed traits, like theory, kinder only ever usable, if you're like in a generic context and, for example, like a lot of us, coming back to the question of difference between interfaces in a language like Java, you may have an interface and the type that implements that, and maybe at some point you don't really care about actual datatype anymore, but only about the stuff.

B

That's implanted in the iterator and, for example, you may want to have something like vector or list of only objects of that trait. It's rate interface whatever.

B

But you may want to be able to put different types types in there like, for example, as if you would want to have an vector of displayable objects, but you can't really do that in respeakers, 2f and yet that that they have may have different sizes and therefore you can't really put them in a vector, but a third possibility of do to do something like that to create a vector of displayable objects. There.

A

A

Not without being very explicit about what you're doing, though, because what you're doing is taking a type and throwing away everything you know about it, except for that it implements display, and then you put it in a box and say: oh now, I have a pointer to something that I know implants display, and then you can do this with. Basically every type you know influences play and put all of these boxes into a vector. So then, you have literally the type back of box of display.

B

I've been searching for that and I kind of thought that the solution is gonna, be as something which boxes, but what's the syntax for that or is there a specific name for it? It's not really like it's this cord, some somewhat doesn't have a name.

A

No, no, certainly not. Oh, look I even tested my examples, I'm going to real, quick like it's right, so the syntax is.

A

This, but now you need to actually say what the hell this x and y and z are, and indeed they are box new of, for example, some number and the type of this X is box. 32 and.

A

Actually, I'm not gonna bother with the other ones, the type of this guy as back of box of a 32.

A

So let me see if this even compiles.

A

Yes, it does, but it not using X 1 X s, okay, fair enough! Now we're going to do a very complex thing and say this is actually display.

A

And now, just to prove this actually works. You're gonna do this and see if it's still compiled fair enough. Oh.

A

A

Yes, just because I'm buzzed up as a warning, this is: how did you yeah very generic boxing stuff? It's.

B

Actually helped me quite a lot thanks sure.

A

There are more variants of this. You can also write a vector of playable pointers, for example, if you don't want to actually box them, but just want to have a reference start on a vector to something you know is displayable the implementation detail. Processors may be the same. You do in most other languages, there's the V table. This is a virtual virtual function for table, so this box is actually ponder to your data and the pointer to a table that contains all the methods display is implemented. Is in this containing basically.

F

I'm interested to know what is happening behind the scenes, so what kind of code machine code is generated for these statements for.

A

F

One yes for it in in Java, there's something like dynamic, binding or whatever. So what is happening in rust does.

C

F

Out which methods are there, then he searched them somewhere, or does he straight go into a routine very.

A

Good question: so if you do this or actually, if you do any of this and use it like this, you get static dispatch. So at compile time there is a caller function to a call statement to well-known function that is specific to the type you are using. For example, this is one implementation of the make truthful make true function. This is another one, and both of them are somewhere in your machine code and depending on what you're calling make true on the correct one gets selected. So this also true for very generic code.

A

So, for example, if you have this is implemented for every T, where T is cloneable, for example, and T in your case is a string. Concrete implementation for clone will be generated for strengths. This is called monomer physician. So, instead of having one implementations that cover us all cases, the very specific implementation will it be generated for the specific case of types you provide.

A

If, on the other hand, you are doing this you're, basically enforcing the compiler to use dynamic dispatch, I'm, not sure how jars implementation looks under the odd but I'm pretty sure they are most of the time using dynamic dispatch, except where they can prove with escape analysis and I.

A

Don't know, maybe some other techniques that only ever one type will be using this method.

A

Questions alright. Thank you very much.