Traits
A trait tells the Rust compiler about functionality a particular type has and can share with other types. We can use traits to define shared behavior in an abstract way. We can use trait bounds to specify that a generic type can be any type that has certain behavior.
Note: Traits are similar to interfaces in other languages, although with some differences.
Examples
struct Sheep { naked: bool, name: String } trait Animal { // Associated function signature; `Self` refers to the implementor type. fn new(name: String) -> Self; // Method signatures; these will return a string. fn name(&self) -> String; fn noise(&self) -> String; // Traits can provide default method definitions. fn talk(&self) { println!("{} says {}", self.name(), self.noise()); } } impl Sheep { fn is_naked(&self) -> bool { self.naked } fn shear(&mut self) { if self.is_naked() { // Implementor methods can use the implementor's trait methods. println!("{} is already naked...", self.name()); } else { println!("{} gets a haircut!", self.name); self.naked = true; } } } // Implement the `Animal` trait for `Sheep`. impl Animal for Sheep { // `Self` is the implementor type: `Sheep`. fn new(name: String) -> Sheep { Sheep { name: name, naked: false } } fn name(&self) -> String { self.name.clone() } fn noise(&self) -> String { if self.is_naked() { "baaaaah?".to_string() } else { "baaaaah!".to_string() } } // Default trait methods can be overridden. fn talk(&self) { // For example, we can add some quiet contemplation. println!("{} pauses briefly... {}", self.name, self.noise()); } } fn main() { // Type annotation is necessary in this case. let mut dolly: Sheep = Animal::new("Dolly".to_string()); // TODO ^ Try removing the type annotations. dolly.talk(); dolly.shear(); dolly.talk(); }
Exercises
- 🌟🌟
// Fill in the two impl blocks to make the code work. // DON'T modify the code in `main`. trait Hello { fn say_hi(&self) -> String { String::from("hi") } fn say_something(&self) -> String; } struct Student {} impl Hello for Student { } struct Teacher {} impl Hello for Teacher { } fn main() { let s = Student {}; assert_eq!(s.say_hi(), "hi"); assert_eq!(s.say_something(), "I'm a good student"); let t = Teacher {}; assert_eq!(t.say_hi(), "Hi, I'm your new teacher"); assert_eq!(t.say_something(), "I'm not a bad teacher"); println!("Success!"); }
Derive
The compiler is capable of providing basic implementations for some traits via
the #[derive] attribute. For more info, please visit here.
- 🌟🌟
// `Centimeters`, a tuple struct that can be compared #[derive(PartialEq, PartialOrd)] struct Centimeters(f64); // `Inches`, a tuple struct that can be printed #[derive(Debug)] struct Inches(i32); impl Inches { fn to_centimeters(&self) -> Centimeters { let &Inches(inches) = self; Centimeters(inches as f64 * 2.54) } } // ADD some attributes to make the code work! // DON'T modify other code! struct Seconds(i32); fn main() { let _one_second = Seconds(1); println!("One second looks like: {:?}", _one_second); let _this_is_true = (_one_second == _one_second); let _this_is_false = (_one_second > _one_second); let foot = Inches(12); println!("One foot equals {:?}", foot); let meter = Centimeters(100.0); let cmp = if foot.to_centimeters() < meter { "smaller" } else { "bigger" }; println!("One foot is {} than one meter.", cmp); }
Operator
In Rust, many of the operators can be overloaded via traits. That is, some operators can be used to accomplish different tasks based on their input arguments. This is possible because operators are syntactic sugar for method calls. For example, the + operator in a + b calls the add method (as in a.add(b)). This add method is part of the Add trait. Hence, the + operator can be used by any implementor of the Add trait.
- 🌟🌟
use std::ops; // Implement fn multiply to make the code work. // As mentioned above, `+` needs `T` to implement `std::ops::Add` Trait. // So, what about `*`? You can find the answer here: https://doc.rust-lang.org/core/ops/ fn multipl fn main() { assert_eq!(6, multiply(2u8, 3u8)); assert_eq!(5.0, multiply(1.0, 5.0)); println!("Success!"); }
- 🌟🌟🌟
// Fix the errors, DON'T modify the code in `main`. use std::ops; struct Foo; struct Bar; struct FooBar; struct BarFoo; // The `std::ops::Add` trait is used to specify the functionality of `+`. // Here, we make `Add<Bar>` - the trait for addition with a RHS of type `Bar`. // The following block implements the operation: Foo + Bar = FooBar impl ops::Add<Bar> for Foo { type Output = FooBar; fn add(self, _rhs: Bar) -> FooBar { FooBar } } impl ops::Sub<Foo> for Bar { type Output = BarFoo; fn sub(self, _rhs: Foo) -> BarFoo { BarFoo } } fn main() { // DON'T modify the code below. // You need to derive some trait for FooBar to make it comparable. assert_eq!(Foo + Bar, FooBar); assert_eq!(Foo - Bar, BarFoo); println!("Success!"); }
Use trait as function parameters
Instead of a concrete type for the item parameter, we specify the impl keyword and the trait name. This parameter accepts any type that implements the specified trait.
- 🌟🌟🌟
// Implement `fn summary` to make the code work. // Fix the errors without removing any code line trait Summary { fn summarize(&self) -> String; } #[derive(Debug)] struct Post { title: String, author: String, content: String, } impl Summary for Post { fn summarize(&self) -> String { format!("The author of post {} is {}", self.title, self.author) } } #[derive(Debug)] struct Weibo { username: String, content: String, } impl Summary for Weibo { fn summarize(&self) -> String { format!("{} published a weibo {}", self.username, self.content) } } fn main() { let post = Post { title: "Popular Rust".to_string(), author: "Sunface".to_string(), content: "Rust is awesome!".to_string(), }; let weibo = Weibo { username: "sunface".to_string(), content: "Weibo seems to be worse than Tweet".to_string(), }; summary(post); summary(weibo); println!("{:?}", post); println!("{:?}", weibo); } // Implement `fn summary` below.
Returning Types that Implement Traits
We can also use the impl Trait syntax in the return position to return a value of some type that implements a trait.
However, you can only use impl Trait if you’re returning a single type, use Trait Objects instead when you really need to return several types.
- 🌟🌟
struct Sheep {} struct Cow {} trait Animal { fn noise(&self) -> String; } impl Animal for Sheep { fn noise(&self) -> String { "baaaaah!".to_string() } } impl Animal for Cow { fn noise(&self) -> String { "moooooo!".to_string() } } // Returns some struct that implements Animal, but we don't know which one at compile time. // FIX the errors here, you can make a fake random, or you can use trait object. fn random_animal(random_number: f64) -> impl Animal { if random_number < 0.5 { Sheep {} } else { Cow {} } } fn main() { let random_number = 0.234; let animal = random_animal(random_number); println!("You've randomly chosen an animal, and it says {}", animal.noise()); }
Trait bound
The impl Trait syntax works for straightforward cases but is actually syntax sugar for a longer form, which is called a trait bound.
When working with generics, the type parameters often must use traits as bounds to stipulate what functionality a type implements.
- 🌟🌟
fn main() { assert_eq!(sum(1, 2), 3); } // Implement `fn sum` with trait bound in two ways. fn sum<T>(x: T, y: T) -> T { x + y }
- 🌟🌟
// FIX the errors. struct Pair<T> { x: T, y: T, } impl<T> Pair<T> { fn new(x: T, y: T) -> Self { Self { x, y, } } } impl<T: std::fmt::Debug + PartialOrd> Pair<T> { fn cmp_display(&self) { if self.x >= self.y { println!("The largest member is x = {:?}", self.x); } else { println!("The largest member is y = {:?}", self.y); } } } struct Unit(i32); fn main() { let pair = Pair{ x: Unit(1), y: Unit(3) }; pair.cmp_display(); }
- 🌟🌟🌟
// Fill in the blanks to make it work fn example1() { // `T: Trait` is the commonly used way. // `T: Fn(u32) -> u32` specifies that we can only pass a closure to `T`. struct Cacher<T: Fn(u32) -> u32> { calculation: T, value: Option<u32>, } impl<T: Fn(u32) -> u32> Cacher<T> { fn new(calculation: T) -> Cacher<T> { Cacher { calculation, value: None, } } fn value(&mut self, arg: u32) -> u32 { match self.value { Some(v) => v, None => { let v = (self.calculation)(arg); self.value = Some(v); v }, } } } let mut cacher = Cacher::new(|x| x+1); assert_eq!(cacher.value(10), __); assert_eq!(cacher.value(15), __); } fn example2() { // We can also use `where` to construct `T` struct Cacher<T> where T: Fn(u32) -> u32, { calculation: T, value: Option<u32>, } impl<T> Cacher<T> where T: Fn(u32) -> u32, { fn new(calculation: T) -> Cacher<T> { Cacher { calculation, value: None, } } fn value(&mut self, arg: u32) -> u32 { match self.value { Some(v) => v, None => { let v = (self.calculation)(arg); self.value = Some(v); v }, } } } let mut cacher = Cacher::new(|x| x+1); assert_eq!(cacher.value(20), __); assert_eq!(cacher.value(25), __); } fn main() { example1(); example2(); println!("Success!"); }
You can find the solutions here(under the solutions path), but only use it when you need it :)