What makes something a “trait object”?

by

You have trait objects when you have a pointer to a trait.
Box, Arc, Rc and the reference & are all, at their core, pointers. In terms of defining a “trait object” they work in the same way.

“Trait objects” are Rust’s take on dynamic dispatch.
Here’s an example that I hope helps show what trait objects are:

// define an example struct, make it printable
#[derive(Debug)]
struct Foo;

// an example trait
trait Bar {
    fn baz(&self);
}

// implement the trait for Foo
impl Bar for Foo {
    fn baz(&self) {
        println!("{:?}", self)
    }
}

// This is a generic function that takes any T that implements trait Bar.
// It must resolve to a specific concrete T at compile time.
// The compiler creates a different version of this function
// for each concrete type used to call it so &T here is NOT
// a trait object (as T will represent a known, sized type
// after compilation)
fn static_dispatch<T>(t: &T)
where
    T: Bar,
{
    t.baz(); // we can do this because t implements Bar
}

// This function takes a pointer to a something that implements trait Bar
// (it'll know what it is only at runtime). &dyn Bar is a trait object.
// There's only one version of this function at runtime, so this
// reduces the size of the compiled program if the function
// is called with several different types vs using static_dispatch.
// However performance is slightly lower, as the &dyn Bar that
// dynamic_dispatch receives is a pointer to the object +
// a vtable with all the Bar methods that the object implements.
// Calling baz() on t means having to look it up in this vtable.
fn dynamic_dispatch(t: &dyn Bar) {
    // ----------------^
    // this is the trait object! It would also work with Box<dyn Bar> or
    // Rc<dyn Bar> or Arc<dyn Bar>
    //
    t.baz(); // we can do this because t implements Bar
}

fn main() {
    let foo = Foo;
    static_dispatch(&foo);
    dynamic_dispatch(&foo);
}

For further reference, there is a good Trait Objects chapter of the Rust book

More Related Contents:

  1. Understanding Traits and Object Safety
  2. Traits and Rust
  3. How to get a reference to a concrete type from a trait object?
  4. Why can impl trait not be used to return multiple / conditional types?
  5. How do I implement a trait I don’t own for a type I don’t own?
  6. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  7. How do I return an instance of a trait from a method?
  8. I implemented a trait for another trait but cannot call methods from both traits
  9. Sending trait objects between threads in Rust
  10. The trait cannot be made into an object
  11. Why would I implement methods on a trait instead of as part of the trait?
  12. How does the mechanism behind the creation of boxed traits work?
  13. Trait implementation for both a trait object and for direct implementors of the trait
  14. Why is the `Sized` bound necessary in this trait?
  15. How can I implement Rust’s Copy trait?
  16. Is there any trait that specifies numeric functionality?
  17. How do I pass a closure through raw pointers as an argument to a C function?
  18. Can’t implement a trait I don’t own for all types that implement a trait I do own
  19. How do I specify that a struct field must implement a trait?
  20. Rust equivalent to Swift’s extension methods to a protocol?
  21. Cannot use moved BufReader after for loop with bufreader.lines()
  22. How do I pass Rc to a function accepting Rc?
  23. Why does using Option::map to Box::new a trait object not work?
  24. What is the cited problem with using generic type parameters in trait objects?
  25. Do I have to implement a trait twice when implementing it for both reference and non-reference types?
  26. How do I create a heterogeneous collection of objects?
  27. Are polymorphic variables allowed?
  28. Need holistic explanation about Rust’s cell and reference counted types
  29. Why does Rust disallow mutable aliasing?
  30. What is the purpose of the unit type in Rust?

Leave a Comment