How to get a reference to a concrete type from a trait object?

by

There are two ways to do downcasting in Rust. The first is to use Any. Note that this only allows you to downcast to the exact, original concrete type. Like so:

use std::any::Any;

trait A {
    fn as_any(&self) -> &dyn Any;
}

struct B;

impl A for B {
    fn as_any(&self) -> &dyn Any {
        self
    }
}

fn main() {
    let a: Box<dyn A> = Box::new(B);
    // The indirection through `as_any` is because using `downcast_ref`
    // on `Box<A>` *directly* only lets us downcast back to `&A` again.
    // The method ensures we get an `Any` vtable that lets us downcast
    // back to the original, concrete type.
    let b: &B = match a.as_any().downcast_ref::<B>() {
        Some(b) => b,
        None => panic!("&a isn't a B!"),
    };
}

The other way is to implement a method for each “target” on the base trait (in this case, A), and implement the casts for each desired target type.

Wait, why do we need as_any?

Even if you add Any as a requirement for A, it’s still not going to work correctly. The first problem is that the A in Box<dyn A> will also implement Any… meaning that when you call downcast_ref, you’ll actually be calling it on the object type A. Any can only downcast to the type it was invoked on, which in this case is A, so you’ll only be able to cast back down to &dyn A which you already had.

But there’s an implementation of Any for the underlying type in there somewhere, right? Well, yes, but you can’t get at it. Rust doesn’t allow you to “cross cast” from &dyn A to &dyn Any.

That is what as_any is for; because it’s something only implemented on our “concrete” types, the compiler doesn’t get confused as to which one it’s supposed to invoke. Calling it on an &dyn A causes it to dynamically dispatch to the concrete implementation (again, in this case, B::as_any), which returns an &dyn Any using the implementation of Any for B, which is what we want.

Note that you can side-step this whole problem by just not using A at all. Specifically, the following will also work:

fn main() {
    let a: Box<dyn Any> = Box::new(B);
    let _: &B = match a.downcast_ref::<B>() {
        Some(b) => b,
        None => panic!("&a isn't a B!")
    };    
}

However, this precludes you from having any other methods; all you can do here is downcast to a concrete type.

As a final note of potential interest, the mopa crate allows you to combine the functionality of Any with a trait of your own.

More Related Contents:

  1. Traits and Rust
  2. Why can impl trait not be used to return multiple / conditional types?
  3. How do I implement a trait I don’t own for a type I don’t own?
  4. What makes something a “trait object”?
  5. Is it possible to use `impl Trait` as a function’s return type in a trait definition?
  6. How do I return an instance of a trait from a method?
  7. I implemented a trait for another trait but cannot call methods from both traits
  8. Why would I implement methods on a trait instead of as part of the trait?
  9. How does the mechanism behind the creation of boxed traits work?
  10. Trait implementation for both a trait object and for direct implementors of the trait
  11. Why is the `Sized` bound necessary in this trait?
  12. How can I implement Rust’s Copy trait?
  13. Is there any trait that specifies numeric functionality?
  14. Understanding Traits and Object Safety
  15. How do I pass a closure through raw pointers as an argument to a C function?
  16. Can’t implement a trait I don’t own for all types that implement a trait I do own
  17. How do I specify that a struct field must implement a trait?
  18. Rust equivalent to Swift’s extension methods to a protocol?
  19. Cannot use moved BufReader after for loop with bufreader.lines()
  20. Do I have to implement a trait twice when implementing it for both reference and non-reference types?
  21. How does for syntax differ from a regular lifetime bound?
  22. Why is the mutable reference not moved here?
  23. Conflicting implementations of trait in Rust
  24. How do I use static lifetimes with threads?
  25. How can I create a function with a variable number of arguments?
  26. Why is the bound `T: ‘a` required in order to store a reference `&’a T`?
  27. Type mismatches resolving a closure that takes arguments by reference
  28. How do I disambiguate traits in Rust?
  29. Comparing every element in a vector with the next one
  30. How can I build multiple binaries with Cargo?

Leave a Comment