Rust Programming Language Rust Linz, 19 Oct 2020

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: Rust Linz, October 2020 - Valentin Tolmer - How not to rely on inheritance

Description

How not to rely on inheritance
As opposed to many languages, Rust doesn't have a concept of inheritance, relying instead on Traits. In this talk, we'll talk about Traits and how to use them for common programming patterns.

About Valentin Tolmer
I am a craftsman, always working to improve my code and others' around me.

Slides: https://docs.google.com/presentation/d/1qGrhRDUgFrnMsSm4MHO0IGozfSlNomn3mlmktWcvI5M/edit

A

Thank you so yeah, um so yeah, I've been I've been working on uh with rust for side projects and it's an honor and a pleasure to to be able to speak at this first meetup. uh Thank you for inviting me so today. I would like to share a very crucial, important feature of rust, which is well. You know it already it's traits.

A

This talk is mainly aimed at rust, beginners with a background in programming, usually with object-oriented languages such as c plus, plus java or c sharp I'll, be mainly talking about uh about java and c blossoms as comparison to rust. But of course that applies to many object-oriented languages.

A

So let's have a look at how we can avoid relying an inheritance, because not everyone has a rich uncle who can conveniently die and leave you a lot of money. How do you? How do you get by without inheritance, and how does rust do it and yeah? Let's, let's dive in so there are different approaches to the same problem.

A

The core problem that we have is that we want to write generic code. So let's say that we want to manipulate animals and all animals, at least those that we want to manipulate, make a sound. So if it's a dog, we want it to bark. Otherwise, if it's a cat, we want it to meow. Otherwise, if it's a snake, we want it to hiss and so on.

A

uh So we could write code like this. If dog then bark else, if then meow, but that's very uh repetitive, you have to list it everywhere that you want to that. You want them to make a sound and whenever you add a new type, then suddenly you have to change every new every call site, because every call site has to handle the new animal and also like, if you want to take an animal as parameter or store it in a collection or return it.

A

What is the type of a dog or a cat or a snake or and so on, um so you could model that within an interest, but that's not what we're here to talk about. So let's have a look at how java does it so java?

A

Usually you would write an abstract class animal and you would define a function cry that is, that is what animals do and then you can create a class cat that extends animal that inherits from animal and then implement that function cry you don't have to do it through an abstract class. You can do well, you could do it through a concrete class, even though it's usually bad style, or you can do it through an interface which is a bit like an abstract class, except that it cannot have fields.

A

So to summarize, in java, you can only inherit from a single class, but you can implement multiple interfaces. The interfaces cannot contain fields, but the classes can and the interfaces can provide a default implementation for the for some functions.

A

Okay, now, let's have a look at how c, plus plus uh does it. So this is again things that most people know I'm just laying the ground for what we're going to compare it against. So in c, plus plus, you would do similar a similar thing to java. You would have a class animal that has a virtual method that is not implemented here.

A

That's d equals zero and it's abstract only because it has an equal, zero method and then you would write a class cat that inherits from animal and and override the method cry to say when a cat cries.

B

A

Goes there, so the thing is in c plus plus, you do not have a clear boundary between a class, an abstract class and an interface. So in order to implement multiple interface, you have to have multiple inheritance again.

B

Because there's no.

A

Boundary between a class, an abstract class and an interface, an abstract class is only abstract because it has a function that is not implemented and an interface is a java concept that doesn't really translate to c, plus plus so uh with multiple inheritance. You can even have trouble with the time and inheritance where you inherit from two classes that both inherit from the same so from which path. Do you get your your inheritance from the top one? It's it can become? It can be complex.

A

So that's why people usually recommend composition over inheritance, but that doesn't always work it has. I mean there are some throwbacks another way that c writes generic code is with templates.

A

So, for instance, here we have a function, make it cry that takes an animal and uh and calls animal that cry. However, here I wrote a type name animal, but I could have written type name t and then take a constitutive because it doesn't the the name. Animal is doesn't mean anything there, it's just a name for the type and we don't have.

A

uh We don't have a way to restrict to um to the the interface animal, and actually you could pass something: that's not an animal, but as long as it has the cry method, it would work.

A

So this is what we call duck typing if it quarks it's a duck. If it cries, it's an animal and we don't really know if it's actually what we meant by an animal. But this is uh how templates work.

A

There is no interface declaration, it's going to come in c class, 20 with concepts, but it's not there yet, uh and then this so the templates are doing monomorphization so meaning they copy paste the function for every type that it's used with and then inline the type which makes a different function for every type. There's no one function that handles every type. It's just a copy of that function.

A

Okay, now that the context is set, let's have a look at how rust does it so for us we have traits so a trait. For instance, we can introduce the trait animal that has a function cry and then, if we want to implement a cat, then we declare the cat. This is a strut, it has fields or not doesn't matter and then separately from the declaration of the trait and the struct.

A

We we say that cat implements animals, so we implement animal for the cat type and since animal requires you to to explicit the explicitly define the method cry, we have to say well cry for cat. Does this so another.

B

A

If we have a stroke dog that has a name, then, if we implement animal for dog, then we can have a different implementation say my name is I mean woof and then that's how a dog will cry.

A

In summary, a risk trait declares an interface it's decoupled from the type declaration and from the trait declaration a type can implement multiple traits and traits don't have fields, they can only have methods. So it's a little bit like java interfaces, except that they are used both statically and dynamically.

A

We'll get a bit more into that right now. So how are they used dynamically?

A

For instance, if you want to write the make and cry in in rest, you would say I take a pointer like a reference to an animal, but since animal is not a concrete type, you have to say to a dynamic type that implements animal. So that's what the little din keyword.

A

uh Let me point it that's what the little din keyword means and then you can. You can use animal.cry and um because it's a it's a method of animal- and here you only know that it implements the type animal to trait animal, so you can only use methods of the trait animal so like in c plus, you cannot receive the animal by value, because animal is not a concrete type, so you cannot copy it or you can you can you cannot move it?

A

You can just receive it by where it's defined somewhere else, so it has to be by by by reference or mutable reference or in a box or something like this in java. We don't have this problem, because every object is a pointer anyway, so we pass pointers everywhere.

A

Okay. Now? What? If I want to return an animal? Let's say I have a barn and inside that barn, there's something there are animals, and I just want to get the first animal.

A

So we have our our function, get barn animal that takes a barn and return an animal from the barn. So once again, you can see that we're returning a reference to a din animal, meaning we're returning a reference to something that we know implements the trait animal. But that's all we know I left some blanks in the in the function definition, because if you've, if you played with the rest, a little bit you've ran into this uh lifetimes.

A

Just I just wanted to say that here we that the lifetimes are also relevant, because it's a reference that we're taking and returning. So here we're constraining implicitly the lifetime of the return uh animal to the lifetime of the barn.

A

And yeah, so as an uh as in taking arguments, you cannot return a value of an animal. You have to return a reference or a box now what if we want to do static dispatch, so static dispatch is when we know at compile.

B

A

That we're what is the type that we're manipulating so, for instance, here we're gonna, be we're gonna call make it cry on a specific animal.

A

So here t is the type of the animal we don't know what type it is, but we know for sure it's one concrete, specific animal and we know that it implements the trait animal because we wrote it.

A

We wrote it here and since we know that it's an animal, we know that we can call cry on it. We cannot access any other methods of t like we would be able to in c plus, because we are limited to what the interface animal says.

A

So we can only use methods of the trait.

A

And this is lexi plus plus templates. This is monomorphization, so we're going to make a copy of that function for every animal, so there's going to be make it cry that takes a cat, make it cry that takes a dog, make it cry that takes something else.

A

And here we can take the the animal by value, because we know the exact type it's t so and make it right that takes the cat. We know that it's a cat, so we can take a cat by value. We know the type.

A

And uh yeah and c plus plus you can do duct, typing and uh and use pretty much anything.

A

So if you want to return uh an animal well, it's the same. If we want to, we can return by value. It's okay, because um because we know the type of the animal is the t you can return by value.

A

Usually when you do static code, the errors are clear, because you know the exact types that are that are involved.

A

The code is usually faster because, instead of having to jump through 0.2 functions, the compiler can optimize and inline the functions, but that could also lead to code loads because you're copy pasting, the same function for every type that you use it with.

A

So it has its uh it's downsides too, but usually it's better to be to do static dispatch. If you can that's not always possible, for instance, if you have a vector of animals, you cannot have a vector of well. If you have different types of animals, then you have to store boxes of reference to them.

A

So for uh for a static dispatch you can you can have a constraint, uh you can have multiple constraints on the type. So, for instance, you can say that t has to be an animal and a runner so that you can use both cry and run, and you can either specify the constraint when you declare the type argument or uh after declaring the the the function and the return type in the constraints below it's just syntax. Both are equivalent.

A

So how are traits used in rust and everyday rust? You will use some traits. I guarantee you, for instance, one trait that you will most likely use is eck and partial egg.

A

So this is how rust knows how to what you mean when you say a equals b. It's because there's an implementation of partial egg that compares the type a and b. So here I've copied a very simplified.

A

Very simplified trait partial egg, so it has one unimplemented method, which is egg so for equal. It takes the the object and another object of the same type and returns the boolean, whether it's true or false, and it gives you for free. The function n e, not equal, which is by default, implemented as the opposite of equal and um there's some difference between partial egg.

B

A

uh Being that partial egg can return false if you pass twice the same object, uh but an egg has to has to return true, if you pass twice the same object uh and we say that egg is like an inherit from partial like if you want, as it has the added constraint, that the type has to be partial egg, because um it means that to be equal comparable, you have to be at least partially equal equal, comparable.

A

Let's not get too deep into that. It's not critical. So, let's implement partial egg for a type. Let's say you have a strict url and it has lots of fields different ways to represent the same thing. So once you want to say that two urls are equivalent or equal if they have the same canonical representation, so you will implement partial egg for url, saying okay, I take uh I take a url and another, so self, with the capital.

A

Editor is the type for which we're implementing the trade so url and then returning a boolean, true or false, and we're just going to compare the canonical representation of the two urls and that way, once you have written this, you can write everywhere, uh url a equals. Your uh you can check if url a equals url b without calling dot x, because the compiler knows that uh you implemented partial x, so it can unwrap the the the equal comparison.

A

Now I want to talk to you about my favorite trait in rust, and it's the the iterator trait for this. I have to introduce the new concept of associated types, so associated types. They will look familiar to c, plus plus template gurus.

A

You have you have a you want to say. The iterator has a next function that returns an option of something, but the the option of something. This type is part of the interface. So you have to say uh what is the type that you're going to return?

A

So item is part of the interface and when you implement iterator, you have to say what is item so item that can be a regular integer or it can be a reference to uh to a cat, or it can even be a dynamic reference to an animal anything goes, but when implementing iterator, you have to say what is the item in addition to implementing next and iterator comes with many more functions that are defined in terms of next.

A

So when you implement iterator, when you implement just next, you get lots of functionality for free.

A

So let's write an iterator.

A

It's going to be a simple one: it's okay, so we'll create the the type always same, and it contains a value then we'll implement iterator for always same say that the the item of the iterator is going to be an integer and then, whenever you call next, we'll just return that integer over and over and over again.

A

So how? How can we use it? Well, we can create an always sync and this way I'm creating it with the value one. So always same is gonna, be always one.

A

Then, let's print with some debug which, by the way, uses the the debug trait we'll take from always one we'll take the first 10 items because we implemented it so that it never returns. None it's an infinite iterator. So we cannot just say, put everything in a vector we'll take the first 10 and put that into a vector, we'll collect.

B

A

Them into a vector, so when we print this, it gives us 1, 1, 1, 1, 1, 1, 1 and so on. You'll notice that I didn't define the take method. For always same. I didn't have to it's an it's a method from iterator that is defined uh in terms of next. It just calls next 10 times, so it returns an iterator. It returns a new iterator that will stop after 10 times.

A

Okay, now, let's say that we're receiving a vector of data, a vector of integer, and we want to return an iterator that takes only those small numbers, those are uh inferior to three and it will infinitely loop over them.

A

For some reason, my problem is that I cannot write. I don't know what to write for the return type. Okay, let's have a look at. Let's cut it down and see what we can do so.

A

The the iter method on vector returns, an std select, enter with item equals i3 i32 because well like here, it's integer because it's a vector of integer it in general. It's like it's returns, an item the same as the vector. What what the vector contains.

A

Then we call dot filter which wraps that iterator into a new iterator of type stdr filter. Then we call cycle which wraps that one into another iterator called cycle.

A

So as a result, the return type of the function should be something along the lines of it's a cycle of a filter of a slice iterator of pointer to animals. Sorry of uh of integers. I should create the slide uh and and then some closure. What is that some closure? Well, if you look back.

B

A

The type in the filter it had a closure to to check that the the numbers were small and the closure has a specific type because some captures and this type we cannot write.

A

That's a problem, because how do I write my function, then? In that case you can just say it returns, some concrete type unspecified, but what we know about the concrete type is that it implements the type iterator with that specific item.

A

However, this is still a placeholder for a single, concrete type. You cannot return two different types just because they both implement iterator.

A

Otherwise you would have to return them by reference to a dynamic object that re that implements iterator here, it's all static, so there's no for there's no v table involved or anything it's just where it's just a convenience function to say that yes, the type that we're returning, we don't know how to write it, but it implements iterator.

A

So a question that I often see beginners ask is why can't I print a vector well effect, t doesn't.

B

A

Display it's a it's a trait it implements debug, but it doesn't implement display. Well, in that case I'll just.

B

Implement it well.

A

You can't why can't you implement it yourself? Well, if everybody could implement could implement vector themselves, then you could have several implementations. That would both be valid and that would lead to chaos and ruin the utter collapse of civilization.

A

Since we don't want that rust has a defense mechanism and that defense mechanism is the orphan rule, so the orphan rule states that you can only implement a trait for a type if you either define the trait in your crate or you define the crack the type in your crate.

A

So it means that you have when you want to implement a trade for a type you have to own at least one of the two or both.

A

So you can implement standard trades for your types. For instance, we implemented the standard, iterated trait or you can implement your own trait for standard types. You can add methods to vector, but you cannot implement standard traits for standard tr types, so you cannot implement a trait introduced in another crate for a time introduced in another crate.

A

Okay, is everyone still following we'll move on to advanced traits, so those are things that you will usually not want to do in your code, but you you should know that it exists in case you need it and it turns out to be the the best implementation.

A

So, for instance, uh you could do some downcasting, which is instance of in java or dynamic, cast in c plus plus, usually not something that you want to do. It usually means that you don't have the right attraction it's possible to do in rust, if you add some boilerplate to the types and so on, it's a bit awkward. Some crates make it easier, but still not great. You have to change the definition.

B

A

B

There's usually a way.

A

To reframe it so that you don't depend on on downcasting, so.

B

Let's say that.

A

You're getting an animal, so this is a java example you're receiving an animal you're checking if it's a dog or a cat, then I want to adopt it and if it's a mosquito, then I want to squash it well, so the techniques I'm about to show were also in java. uh It's just that in rust. uh I want to give you tools when you, when you come around along this problem, to change the way you think and maybe rephrase it reframe it in a way that is better suited for the tools that russ gives you.

A

So you could either extend the trait animal and add the function adoptable. That by default is true, and then, when you implement animal for mosquito, you say that adoptable returns false or you could create a new trainees. You could say that things can be adoptable by default. They are and mosquitoes are not, but you still have to say that for that cats are adoptable and dogs are adoptable and for every animal you still have to implement adoptable as well.

A

In addition to animal and your code would look like this, you take a t and that t is both an animal and adoptable. Since it's both, you can check if it's adoptable, if it's adoptable, then you can pet it which takes an animal. Otherwise, you can squash it.

A

So some of the traits that I presented so far were uh you. You saw them, but you never actually used that you never actually implemented them yourself, for instance debug, partial, egg or egg. I doubt that you actually implemented them yourself. Usually you they have an obvious implementation, so you would just write. Oh you just derived the implementation. From from the structure you that way, dog implements, debug, partial leg and egg with.

B

A

Implementations uh and usually when every field of structure implements a trait you can recursively implement it by calling it recursively on every field and to generate this implementation. With the drive macro, you can actually write your own derived micro for your own traits using procedural macros. I'm not going to get into that because that's a complex topic on its own.

A

um Another thing that we kind of touched on with partial egg and egg is operator overloading to define what the plus does you just have to implement. The trait add for self and the right hand side which, by default itself- and so we could implement, add for a cat say that when we add two cats, it returns an integer and when we add them like it, returns actually to two you'll notice that I implemented it for reference of cat and not for cat itself.

A

You could implement it for cat itself, but then you would be able you would have to move the value into the the plus of the addition operation, and that might not be what you want so, for instance, here where um we're adding twice the same value. So we couldn't do that if it was by value we had to do it by reference um I'll quickly skip over the deref trait, because it's not super super important, but basically it's uh you. You can specify what it means to dereference a type.

A

So, for instance, when you have a man, you can reference it into two kids and uh hey: it's just two kids in a trench coat and you can pass a man to a function that uh that expects two kids, because the compiler will just reference it on its own.

A

Okay, um so autotrades are traits that contain so some traits contain no interface and are used just as marker traits. For instance, we saw that egg in addition to partial egg was just used as a marker to say: oh and those types have the the strong equality, uh the strong equality uh constraint.

A

Some market traits are automatically implemented by the compiler. For instance. uh Sized is just means that you we know, study at compile time the size of your sizing memory of your object.

A

You can't make your own auto trades, except if you're in nightly and with some features, but maybe in the future. You will be able to. There are some other auto trades that are interesting like sand and sync, but usually you don't have to think about them.

A

So in conclusion, um traits are quite different from c plus, plus and java. They resemble java as interfaces or c plus plus uh abstract class, with no fields, but it's not quite the same.

A

Their power comes from the fact that uh the the implementation for a type is separated from both the declaration of the type and the declaration of the trait.

A

um So many things in rest are implemented as traits and they're very crucial to writing. Idiomatic crest and a very nice advantage of traits is that they're used both dynamically and statically for for specifying an interface. So it's the same mechanism for both compile time and runtime.

A

Okay, are there any.

B

Questions hi valentin. Thank you for this presentation. It was very interesting. I did a little bit of work in traits, but I learned a lot of new things. Yes, there are questions and if that's okay for you, I will relay them to you- is that? Okay, yes, okay, there is uh one question. uh Actually in the organizer team um we asked ourselves uh you showed traits in uh in conjunction with structs. Only is it possible to define traits for other types like enums.

A

Yes, it's possible to define traits for any type, including for an integer, so you can, you can add methods to integer by implementing a trait for them and of course it works for enum. You have to be careful whether you're implementing the trade for the entirely or for variance of the enum.

B

Okay, thank you. Thank you very much. The next question comes from matthias. I will just read it to you: will we ever get constant iterators? He asks while and loop can already be used in const functions, but four does not yet work. I suppose that's also because it uses iterators which are not constant. Do you know more about that.

A

B

Don't know more about.

A

That question sorry.

B

Okay, okay, yeah, um the the second thing is also a longer question. I'm not sure if you have discord open, it's in the meetups channel vladimir is asking the only difference. I know between generics, syntax and associated types is that one cannot implement a trait with an associated type multiple times for a type. Are there any other differences, and he brings also an example.

A

So, yes, uh that's one, that's one key concept of associated types. For instance, when you implement uh iterator for vector it can only ever return one type, so you don't want to implement iterator of integer for vector and integrator of string for vector, because both don't make sense at the same time. So when you implement, actually you don't implement iterator for vector, vector, implement iterator for the iterator type returned by vector sorry.

A

um So if you had generics at the at the trade level, then you would be able to say iterator of integer for that vector of string which doesn't make sense. So it's a good point to to point out um the I guess. Another key difference is that you can have default values for um for generics, but I'm not sure that's the case for uh associated types.

A

uh I might be wrong. So it's it's mainly a question of what is the interface that you want to present? Do you want to present an interface that is that is variable on every trait? Or do you want to present a single interface? It's just that you need an extra item, an extra type to be specified.

B

Okay, thank you very much. The next one is a short one um christian asks. Would it make sense to move all the logic into traits and that classes just hold fields.

B

A

Or seriously, of course, yeah.

B

A

This says um this is essentially what happens already, because when, when you add methods to uh to a struct, then you say impul for struct, so you're already doing an implementation block. That is separate from the the data declaration of what the shape of the structure looks like it's just that. Sometimes you want to have some functions that are limited only to a single struct, because it doesn't make sense to have another strike, to define them and so you're.

A

In a sense, you could say that you're implementing an anonymous trait just for that struct, so you're, declaring that this trade, this struct implements an anonymous rate and that the the default input block is the implementation of that nameless, trait and the interface.

B

At the same time, I didn't look it uh from that point of view, but yeah, that's that's an interesting point of view. Yeah. Thank you very much. The next one is um another question, a short one. um You mentioned the diamond problem. I think you mentioned it with c plus, plus.

A

B

Question is: can the kind of diamond problem also happen with traits.

A

So yes, and no because the thing is uh your traits cannot override the methods of another trait. uh Basically traits are just here for the interface.

A

So if you get uh the interface from two different traits, it's okay, what the problem in c plus plus, is that the in the diamond, the two classes in the middle can implement the class at the top in different ways.

A

In rust, you can have a diamond trait implementation. If you could say, except that it's not really a diamond you don't when a trait inherits from another. It just means that it requires the class that implements it to also implement the super trait. So egg doesn't inherit from partial egg in the way that, if you're, if you were to somehow just implement egg, you don't get the the the dot egg and dot any methods, it's just that to implement egg. You have to implement partial egg.

A

So if you had the same requirements from two traits, it's not a problem. You just have to implement the requirements and implement the two traits.

B

Yeah, that's clear, I think you described it very well. I could understand it and I hope the question was answered with that. Let me quickly check whether we have something in the chat. No, I think that chat is empty and meetups and technical discussion yeah. I think you answered all the question. Let me quickly ask the the crowd whether where we have additional questions, this is your last chance to ask your questions live while.

A

People are thinking about.

B

It valentin will you be available for questions on the discord server after your talk for another few minutes. Sure oh awesome awesome. I.

A

Just want to to say I'm coming back to the the concentrator uh question yeah, uh so I don't know specifically about const, but something that I didn't mention about. The iterator trait. Is that it's what powers the for loops. So when you say for a in a vector what happens behind is that uh we there's an into iterator trait, that turns the vector into an iterator, and then we iterate over that with the dot next, and so all of that is just syntactic sugar provided over the iterator trait.

B

Thank you very much. Thank you for pointing that out. um I would like to um point out for people who are watching on youtube, and I know there are some people watching on youtube there. uh We don't use the discussion on youtube. If you want to ask questions, please come to our discord server and ask your questions there. We will relay them to our speakers.

B

Valentine I think we are through. I don't have any more open questions. Thank you very much for this great talk. I learned a lot and I'm pretty sure that it was very interesting for many of our viewers. It was a pleasure having you here and we hope that you also enjoyed giving this presentation here at the rosslyn meetup.

A

Thank you for inviting me it was was very nice. uh It was my first time doing a presentation without seeing the audience, so that was interesting, but uh it was a great opportunity and uh thank you very much.

A