dyn Trait

In addition to using traits for static dispatch via generics, Rust also supports using them for type-erased, dynamic dispatch via trait objects:

  1. struct Dog {
  2.     name: String,
  3.     age: i8,
  4. }
  5. struct Cat {
  6.     lives: i8,
  7. }
  9. trait Pet {
  10.     fn talk(&self) -> String;
  11. }
  13. impl Pet for Dog {
  14.     fn talk(&self) -> String {
  15.         format!("Woof, my name is {}!", self.name)
  16.     }
  17. }
  19. impl Pet for Cat {
  20.     fn talk(&self) -> String {
  21.         String::from("Miau!")
  22.     }
  23. }
  25. // Uses generics and static dispatch.
  26. fn generic(pet: &impl Pet) {
  27.     println!("Hello, who are you? {}", pet.talk());
  28. }
  30. // Uses type-erasure and dynamic dispatch.
  31. fn dynamic(pet: &dyn Pet) {
  32.     println!("Hello, who are you? {}", pet.talk());
  33. }
  35. fn main() {
  36.     let cat = Cat { lives: 9 };
  37.     let dog = Dog { name: String::from("Fido"), age: 5 };
  39.     generic(&cat);
  40.     generic(&dog);
  42.     dynamic(&cat);
  43.     dynamic(&dog);
  44. }

This slide should take about 5 minutes.

  • Generics, including impl Trait, use monomorphization to create a specialized instance of the function for each different type that the generic is instantiated with. This means that calling a trait method from within a generic function still uses static dispatch, as the compiler has full type information and can resolve which type’s trait implementation to use.

  • When using dyn Trait, it instead uses dynamic dispatch through a virtual method table (vtable). This means that there’s a single version of fn dynamic that is used regardless of what type of Pet is passed in.

  • When using dyn Trait, the trait object needs to be behind some kind of indirection. In this case it’s a reference, though smart pointer types like Box can also be used (this will be demonstrated on day 3).

  • At runtime, a &dyn Pet is represented as a “fat pointer”, i.e. a pair of two pointers: One pointer points to the concrete object that implements Pet, and the other points to the vtable for the trait implementation for that type. When calling the talk method on &dyn Pet the compiler looks up the function pointer for talk in the vtable and then invokes the function, passing the pointer to the Dog or Cat into that function. The compiler doesn’t need to know the concrete type of the Pet in order to do this.

  • A dyn Trait is considered to be “type-erased”, because we no longer have compile-time knowledge of what the concrete type is.