Rust Programming Language PDXRust, 7 Oct 2016

Previous Meeting Next Meeting

⏯

youtube image

►

From YouTube: PDXRust May 2016: Mike Cooper - Traits and Types

Description

PDXRust

More on http://www.meetup.com/PDXRust/events/229349425/

Help us caption & translate this video!

http://amara.org/v/2Fi4/

A

Little situations because there are so many bikes in the world, so I'm going to be talking about the trait system and like how it intersects, with the type system, I kind of assume. You know a little bit of rust. We aren't going to cover the the very basics, but if anything is confusing, please interrupt me and ask questions.

A

Raise your hands is good, so first I want to talk about why rusts type system is worse than knowing the type system is basically the skeleton of the language it underlies some of the most important features. It's how we get our type safety, a memory safety. It also does error, handling and flow control. All the operators are implemented with the type system and the trade system, and all of the memory management is done with traits. So this is a very important part of the language to understand so a brief overview of rust types.

A

Everything you must have the type, even if it doesn't look like it does so this program here there are no types it expressly written and that's because rust will automatically detect many types within a function. So the same function with its variables, annotated with their types, looks like this, and it's like this. What the compiler would have figured out well, I, don't know that would have given counted as an I-32, but sometimes we need to tell the compiler what we're talking about the built-in types for like come with the language. There's.

A

This is an incomplete list. There's you basically, true/false characters are a 30 I think there are 32-bit value, that represents a Unicode code point and there's a numeric types which we'll cover in a second arrays and slices and tuples, which all kind of look the same, but are all subtly different. We aren't really going to get into the differences of those because they're, subtle and very complicated and then string and a string.

A

Reference are sort of like array and slice ins, the mara types there's quite a few of them, and this is I'm kind of how they are related. Various different integer sizes, both signed and unsigned, and a few floating-point number is the one interesting one here is the eye size and you size. Those are the Machine type, which means on a 32-bit system. They are 32-bit bits wide on 64-bit system, they're, a 64-bit one. This is also the size of pointers and like array, references so to talk about traits and types.

A

We kind of need a little bit of code that we can work with throughout the example. So this is something very simple thanks to numbers. It doubles the first one as it's in second and returns. It.

A

That is wait. Sorry. This is an older version. Sorry, this adds two numbers together.

A

A

My slides are out of sync one. Second, what I'm seeing on my screen is different.

B

A

Let me fix that real quick.

A

Okay, now we're back insane cool, so you're right. It doubles the first argument as it's a second it returns. It I want to point out the lack of a return keyword here. If you leave off the semicolon on the last expression and statement, it returns it and there's a small example of how it's used.

A

So what if we want to do something with this besides integers, if we want to add, floats together and it doesn't work, so this is the compiler telling you that you've messed up your types, it says, I expected an I-32 and I found underscore underscore is what the RUS compiler uses to mean it's some type but I'm, not exactly sure which one it knows some things about it, and it knows that it's supposed to be a floating point variable, but it doesn't know if it's an f32 or an F, 64 or I think that's all it could be.

A

I could be wrong, so Russ has the ability to make functions like this. It's actually a little clever. We can use what's called generics and it's a generic. You say: I, have it sorry. This is another out-of-sync slide: I have a function called add, which is generic over the type T I want to take two parameters, a which is a T and B, which is a T I'm, going to return something of the same type, then, as the other.

A

It doesn't work as you can see, and the reason this doesn't work is because T's can't do anything. They have no message: they have no operations, they specifically don't have the add operation. If you look at this error message, it says the.

B

A

Operator cannot be applied to type T and there's a helpful message that says: maybe you want to implement the add trait.

A

Flips talk club traits concretely for a moment. This is a quote from the rust book. A trait is a language feature that tells the rest compiler that a functionality a type must provide.

A

The traits are how we constrain types, how we limit it from everything to just some types and in our example, we need to constrain T to only things that can be added. We do that, like this I'm sorry- and this is the ad trait- this is a very simplified version of the ad trait in rust, the actual ones more complex and rather than last I, give this talk. It was too confusing and we spent too much time on it.

A

So reading this I'm assigning a public trait called ad, it has one method named ad that takes a copy of self or it takes self and owns it, and it takes a right hand, side and it returns the same type, the real one, everyone whose argument can be a different type, which is where most of the complexity comes from, but we'll work with this for to them.

A

So here's the version of our of our toy function. It's what I get for updating my slides by the last minute. This says: I'm function, add I'm generic over a type T, which is constrained by the trait add I will take a and B both of type T and I will return some types and that's the complexity of the add trait that I try to remove my slides, I'm, sorry, and so now. This works with anything that can be added together, like a float.

A

So this is so that's like an overview of how the basics of how traits work with the built-in types and how you can use generics and traits to write generic functions. Are there any questions about that before we move on.

B

A

Yeah, so when you're, defining a trait, if you say self, that is whichever type is implementing the trait I'm, pretty sure you can only use it inside traits, but it's really handy for writing generic things. Oh.

B

A

Can you yeah okay, if you the inside any implementation block, not only traits yeah.

A

Yes, um yeah so or you might have something like if you multiply a float by an integer, you get a float okay. So the next time to talk about is custom types, we're not limited by the types that are in Russ to begin with, we can make our own. So this is a very simple type: we're going to be using complex numbers and if you don't understand complex numbers, Sok they're, just a pair of numbers. For now. That's all we need to worry about.

A

This is a structure that just holds 232 numbers very simple, and then we make a instance of complex numbers called sea.

A

Racer structs are a very common way to hold multiple pieces of data and attach behavior to them.

A

To attach behavior, we use in pull blocks. So if we have that struck from last slide, I don't wait. Sorry I need to fullscreen this I didn't notice them.

A

Okay, so if we have the structural Mossad, we can have an implementation for the complex type, we're going to define one method called new new, we'll take two ice reqs named real and Maj, and it will return a instance of the struct with those fields filled in this is a pattern you see quite often in rust to have a method named new, and this way you can more easily create types that complex internal structures.

A

It's also usually a little easier to type like with the keyboard, not what's the type system, but the new method name is not special. It's only by like this is what we do by convention, so we could have other constructors, for example. Here is a zero constructor for complex numbers. It takes no parameters and it returns these, like the zero complex number, there's actually a trait in the things in the standard library, the that is zero, but we are going to use it to that.

A

Okay. So, right now, if we were trying to try and use our toy function on complex numbers, it wouldn't work. That's because we haven't defined how to add two complex numbers. The way we can do that is by implementing the trait ad.

A

So we have our original and Bofur complex and then we have another impulse or it we say I'm going to implement the trait ad for the type complex and then we assign the method that's required by the trait that raised it. We saw earlier, we define, that's that add the takes of yourself and another complex number and returns a complex number.

A

So then, after we've defined this implementation for complex, we can make two complex numbers and we can give them to our toys function. It doubles the first one that returns a second, and this is actually like coming from from some other languages. This is pretty profound in Python. If you try and add two things together, it might work.

B

A

B

A

Rus, you will know at compile time whether this will work in C++. If you have templates I believe they're called I'm, not a cost-plus programmer, but if you trying to add to two things that can be added together, you get nasty error messages. You get miles of miles, long things that say this doesn't work. It rescued a nice, simple error, message pointing exactly where you need to look, and, unlike, for example, go we had to opt in to this behavior we had to say: I can be added this way.

A

You don't have an ADD method on vectors. That adds something to the like to the vectors that accidentally applies to the plus operator. This gives us a really good mix between control of what we want to do without accidentally doing more.

A

Dislike how we aren't restrained to built-in types we're also not restrained and built-in traits, so we can define our own traits there's a trait called shape, shape.

A

We define a shape as something that has an area and that just returns a floating-point number.

A

We can implement rates the same way. We can make a circle structure as a radio, and then we can teach the circles how to find their area. We can implement traits multiple times. We can have another square, and now we can treat these both as shapes because we've implemented the shape trade for both of them.

A

Everything examples how we can use them with this right, so we have a method, big enough, that is generic over a type T, which is constrained to be a shape of an enclosure to the reference to a shape, and if it's area is more than 100, then it is big enough. Once we design a circle with radius, 10 and a square for the side length 5, the circle is big enough and the square is not.

A

The interesting thing about this is big enough. Just like the toy function doesn't need to know anything about the about circles of squares or complex numbers. It only has to know that they are shapes and they fulfill the contract.

A

Well pause here again: are there any questions.

A

um I didn't cover this. The question is: why is it generic overtype t-shape, instead of just enclosure, is a reference to a shape, and this is because traits are not great. Don't have a pattern in memory, you can't like say this is a trait and know exactly how big it is exactly how it looks because traits define behavior, not memory.

A

So in this case, if it's actually going to be in the compiled code, probably two versions of big enough one for circles and one for squares- this isn't always true, sometimes there's dynamic dispatch and other things that I don't worry about.

A

Yeah, that's why you can't just save the lessons to shape.

A

Yeah, you can have a box trade boss, the trade you've heard about me and a reference as well. um Well,.

B

B

hmm Right right, right.

A

um So I guess sometimes you can't just do reference to shape, but you can't, for example, have an enclosure takes a shape by value without the reference because of the memory issues.

A

Okay, so one problem in other languages, with this kind of behavior, is that you might say I want to implement the add trait for I, 32s and redefined behavior, and that brings everyone else so kind of like this I want to define, add to ignore the right hand, side double the left hand side. This would be a very bad thing if you could actually do it in language. So you can't. This is the kind of error message. You'll get there's two different errors here.

A

The first one is that ad is already defined for ia32, like someone's already done it, you can't have it twice. This is this just make sense? If the compiler always knows what you mean can't be ambiguous, and the second error here is I should be my slide. The.

B

A

Is that there's already one in existence? The first error is: what's hold a trait coherence problem and that's that you do not own the trait that you try to implement and you do not implement you do not own the type you're trying to implement it for so. In other words, none of these things are yours. You can't modify them. The actual rules are more complex than that, but that's a pretty basic under that's a pretty good understand. It'll, get you 90% of the way there.

A

Another thing that this does is, if you have like someone a.

B

A

X and library why you cannot implement one of wives traits for one of accidence types, because you are neither you don't own those types or traits, but.

B

A

To implement a trait that you don't own for a type that you do or.

B

A

Great that you do own for a type that you don't, that make sense.

A

Okay, so next I wanted to do actually I should pause here, so that is most of the basics of the types of types of traits. It's all very generic, and not very concrete.

B

A

So we're going to go through some examples next, but I'll pause here again, and anyone want to go over any of that again. That all make sense.

A

Only if you're employed in it for a type that you own, so you have to own one both. So if you pull in a crate, you do not own that craves types or drapes that.

A

Depends on where the trick came from, if you have.

A

B

A

That means clearly.

A

If I remember my history correctly, the way I'm presenting it is pretty close to the original rules and then they weren't they weren't loose enough. So there was a very complicated rewrite that said: okay, now we think we can do everything you want safely and it wasn't good enough and there was another even more complicated rewrite that made the rules even a little more tricky and the good news is you don't have to memorize these, you just try it and if it doesn't work the compiler with hell, you know stop.

A

So a lot of rust is talking with the compiler and like having a conversation like can I. Do this No? No, that's bad! Don't do that! That's not safe.

A

So I want to go over some types that are not the basic types but they're defined in the standard library is a part of the language and there you'll find them just about everywhere. It's going to be option, result that can hashmap and we'll go over each one of these start with option option is either something or nothing.

A

That sounds really simple, but it turns out to be very useful to have in Python or JavaScript. You might have a function that returns the value or undefined or none in Java. You might have its return, something or nulls, and this, if you aren't expecting it, is obtained it's terrible and if you are expecting it is still kind of a pain, I'm, so rough, big sis, into the type system that make you deal with it. You want to return something or nothing. You return an option for something.

A

So here we have a method that says I'm going to get you directions. I want a reference to a start, location and reference to an end location that will give you maybe a path I might fail. There might not be any path between these two, so I might say none, and then this interacts with some. You can see like match on this, so you say, I would like to know in this case. It's in some I will do this and it is none I'll do this.

A

This is where the flow control that I talk about comes in similar to option is result. A result is either something or an error. This is often used when you're dealing with I, oh yeah, reading files or document the Internet. Sometimes things fail, and this is distinct from option in that option. The none is not an error case means I have no answer. To give you a result. It is something or an error, and usually errors have messages attached to them, but not always result is marek over key. The value and AD error.

B

A

In like standard I/o, there's like a standard, I/o error, I tell you there.

B

A

Error I could not read the file or you not have permission, but in other parts.

B

A

The rust there's different errors. You can get I, don't have any absence on. My am.

A

The third type of I wanna talk about is called Zek. This you will like this you'll see everywhere, is basically one of the fundamental types. It is a global array as a dynamic array, it's a vector in many other languages and generally, if you want I, can own a bit of data. That is a list of data.

A

You'll use this instead of a raise, there's a raise or fixed size and generally more difficult to work with, and you can also just like an array you take a slice of vector, which is how you generally pass around the data inside of it.

A

And I'll point out: the Veck is similar to pythons list type or JavaScript arrays.

A

Done right, a slice is like a fat pointer, it's not a copy. The force built-in type I wanna talk about is the hash map. This is similar to JavaScript object or pythons dict, but it's a little pick here because of the type system. So let me walk through this example.

A

We have a mapping of people to their offices. Rather sorry, office numbers to people's names will insert in office one two three. We have Jane Smith in office number 196. We have Sarah Johnson. So if we try and print the we'll get something from office 196, it will say Sarah donphan. If we try and get something for office 999, which is not defined.

A

Your program will crash, so get a panic and just won't go any further. This is because the index rate doesn't return an option. It return, something always something or your program. Crashes hashmaps also have a method get', which does return an option and if you try and get 999 from this with the method, you'll get an option. None I, don't have anything like this and if you were to say get for one two: three, you get a option that says sum and then jane smith.

B

A

Then finally, I'm going to talk about some traits that are in the santur library that are very useful to deal with from an into or sort of a pair that work together from string is sort of a specialization of from it's very useful, and it's also debug and display.

A

So this is uh this is implementing from-from it into our way. You deal with a lot of conversions that are not trivial, so it's it's expensive to do or any hand manipulation of memory, and usually you do.

A

It was from there's a blanket implementation of into that says anything to implement from it will define the reverse relationship for into so here we can design from a tuple of I thirty twos into complex numbers, and so this just takes the two values out of a tuple and puts them into the complex number, and this is useful because you can take a method that is generic I.

A

Did that wrong?

A

You take a message that is generic over some type, that is in too complex, and then, when you call that method, you don't have to necessarily give it a complex number. You give it anything that can change into it, and here you can see how into and from work together, because we've defined from a table by three twos to complex this method works.

A

Right, that's because there's a in the standard library there's a blanket implementation that defaults. Anything that is from X is a into X and give it or something.

B

Into from you,.

A

Right yeah, so that's one of the complexities in the trade. The trade rules is, if you are more specific, you can often implement a trade, that's already implemented. So if you have a super special fast way of reversing your from, you may implement it into trait, but you don't have to.

B

A

It just happens and.

B

That's because.

A

From an end to have this relationship- and that's documented, um it doesn't happen for other trades unless, like those trees, have defined those implementations.

A

Well, it's defined in.

B

The same place as.

A

B

A

Because I didn't cover this, but you can implement trade for some generic kind of type, um so you can blend it for many different types.

A

Right, so what this does, if I had typed it correctly, this should be T which is into simplex and then C is of type T. I should take notes, and so it this is. This is where it makes many copies of the function, one for each type, we're going to.

A

B

It's going to reference, it.

A

Will only make one, but if you take a value it will make multiple copies.

A

All right go ahead: Jim.

A

That's a good question um from is generally much more much easier to implement than into the traits a little nicer, but when you're taking parameters like this, you want to use into because the API is much nicer and they could have done this in one trait. It could have had like a from into trait, but then they can't do that trick where they provide a blanket implementation.

A

So this way you can have you only have to implement half of the of the work, and it would do the rest that make sense.

A

B

A

Yes, actually, what it does is the lifetime of the original see ends right there or like whether that value is no longer accessible and we're defining a new seat. This is how you can apply. So, even though C is not mutable, we can do those give this a new seat.

A

A

I, yes, actually I'm I have an example as soon sort of it's a the from string thing. In particular, it's actually really powerful for my favorite things with trades, so one there's one type of from inches relationship. That's really really common! um That's strings! It's like going from a string to some type or from type to some string, and these are so common. There are specific trades just to this.

A

You have from through which I didn't I did I, don't have the definition here, because it's a bit bigger, but this is one of my favorites lipids and it uses from stir. So let me walk you through this.

A

If a function called read, Nariko for some type T and we're going to constrain T and it returns it of T or again we're going to constrain T to be from sir, that means that you take a string and convert it into T.

A

Well, as NASA does, is it will get it'll make a buffer which is a string. We can fill it data. It will read from standard in from the command line. It will read eight it into that buffer one-line. That unwrapped is because reading from standard in might sail various reasons. If it does fail, this program would crash. You can be a little careful and say: oh, there was an error. L will return something else, but that doesn't fit on the slide.

A

So then we take that string and we trim it to take off any white space, especially that new line on the end and then parse it parse is something that is defined by from strength.

A

No parse is part of the from string that so it take anything, takes a string return, something that is from string and then unwrap site to that might sail to and then down below. We call this twice. I would like to read an I-32 I'd like to read an f32, and just like you said earlier, it will figure out what you wanted to return based on what's happening.

A

Does that make sense.

A

Yeah, this can only deal with one value at a time, and you can make a version of this that, like splits on commas and then parses both sides, as that's also a pretty useful thing- that there's some only deal with one type per line.

A

A

No because tea itself has no achieves not define anything about parse or from string or even if you never mention tea after mention some type right.

B

A

Sorry I wanted to fix my slides what wait as we're talking.

A

Yeah so hopefully it makes a little more sense. There was a trim item, I didn't call it as method and I'd renamed about four from s in the past. So sorry about that.

A

Okay, so I mentioned it feel like from and into our pair of hair and from store lets. You go from strings to some object. We don't have the other side of that pair. One instance of that other side are the debugging display traits anytime. You try and print something you're, either probably going to be interacting with either debug or display. If you use just two curly braces, that's display, that's meant for like pretty human output and if you use a quest or colon question mark, that is the debug version yeah.

A

But this is more like internal guts of the system.

A

And this is the the traits very simplified version of the scrapes debugging displays are similar. They both have a method called format which takes some reference to some object, and then they give it a mutable formatter function, and implementers of this trait are expected to you to call methods on the formatter to write things out to whatever string you're doing dealing with I might be a file, it might be string, it might be standard out a lot of options.

A

So if you on implement display, for example, for our complex numbers now, let's just step of that type forgot- that's fine, but you call various methods on format to write to that string and you write your different variables. If you want to implement debug, you can do it for it. You can do it automatically. If you say I would like a imitation of debug. The compiler knows how to do that old derivation and for structs.

A

As long as all of your methods or all of your members are also implementing debug, you can automatically on plenty bug. You get output times like this.

A

Basically, every struct could probably implement debug unless for some reason to camp and as I can't, maybe you should think about why I camp? This is very useful for debugging error messages. This generally makes your life better implanting display is something that not everything needs to do, but if you, if you want to write so that's qyx mayline our interface is that's pretty useful and turn. If no, please.

A

B

A

This is part of the compiler I believe that compiler plugins, which are only available in nightly, can do this, but I'm not familiar with that.

A

And there are other tribes traits, you can derive, I, think copy and.

A

One of them are show leaked actually, and you can also do Ord and I fully. So I am I'm, not sure uh sighs. Maybe um so all these are traits we're talking about. So, if example, partial ich means it's partial equality means you can purchase objects and say: are they equal or not, and sometimes I might say, I don't know, because floating-point numbers.

B

A

We were talk about this earlier. The the foot, the floating point standard requires that there is a value called, not a number which it's not equal to itself is not greater than itself, not less than it's all stated. It's just not anything to anything. So that's why we have Marshall League and you look at all the all the types in the standard library, the only one that doesn't implement eat this whole equality is floating points, so I, Triple E did this to us.

A

Ord is the trail. If you compare numbers or some car things like, is it greater than it's a less than so for, like a sorting algorithm requires that it's types be Ord or partial org, depending on the algorithm a lot of these built-ins? You can derive any more questions.

A

That's the end of my slides I'm happy to talk about anything we covered today. We want to go into more depth on.

A