Traits

Rust lets you abstract over types with traits. They’re similar to interfaces:

1. trait Greet {
2. fn say_hello(&self);
3. }

5. struct Dog {
6. name: String,
7. }

9. struct Cat;  // No name, cats won't respond to it anyway.

11. impl Greet for Dog {
12. fn say_hello(&self) {
13. println!("Wuf, my name is {}!", self.name);
14. }
15. }

17. impl Greet for Cat {
18. fn say_hello(&self) {
19. println!("Miau!");
20. }
21. }

23. fn main() {
24. let pets: Vec<Box<dyn Greet>> = vec![
25. Box::new(Dog { name: String::from("Fido") }),
26. Box::new(Cat),
27. ];
28. for pet in pets {
29. pet.say_hello();
30. }
31. }

• Traits may specify pre-implemented (default) methods and methods that users are required to implement themselves. Methods with default implementations can rely on required methods.
• Types that implement a given trait may be of different sizes. This makes it impossible to have things like Vec<Greet> in the example above.
• dyn Greet is a way to tell the compiler about a dynamically sized type that implements Greet.
• In the example, pets holds Fat Pointers to objects that implement Greet. The Fat Pointer consists of two components, a pointer to the actual object and a pointer to the virtual method table for the Greet implementation of that particular object.

Compare these outputs in the above example:

println!("{} {}", std::mem::size_of::<Dog>(), std::mem::size_of::<Cat>()); println!("{} {}", std::mem::size_of::<&Dog>(), std::mem::size_of::<&Cat>()); println!("{}", std::mem::size_of::<&dyn Greet>()); println!("{}", std::mem::size_of::<Box<dyn Greet>>());