Why can’t `&(?Sized + Trait)` be cast to `&dyn Trait`?

by

This problem can be reduced to the following simple example (thanks to turbulencetoo):

trait Foo {}

fn make_dyn<T: Foo + ?Sized>(arg: &T) -> &dyn Foo {
    arg
}

At first glance, it really looks like this should compile, as you observed:

  • If T is Sized, the compiler knows statically what vtable it should use to create the trait object;
  • If T is dyn Foo, the vtable pointer is part of the reference and can just be copied to the output.

But there’s a third possibility that throws a wrench in the works:

  • If T is some unsized type that is not dyn Foo, even though the trait is object safe, there is no vtable for impl Foo for T.

The reason there is no vtable is because the vtable for a concrete type assumes that self pointers are thin pointers. When you call a method on a dyn Trait object, the vtable pointer is used to look up a function pointer, and only the data pointer is passed to the function.

However, suppose you implement a(n object-safe) trait for an unsized type:

trait Bar {}
trait Foo {
    fn foo(&self);
}

impl Foo for dyn Bar {
    fn foo(&self) {/* self is a fat pointer here */}
}

If there were a vtable for this impl, it would have to accept fat pointers, because the impl may use methods of Bar which are dynamically dispatched on self.

This causes two problems:

  • There’s nowhere to store the Bar vtable pointer in a &dyn Foo object, which is only two pointers in size (the data pointer and the Foo vtable pointer).
  • Even if you had both pointers, you can’t mix and match “fat pointer” vtables with “thin pointer” vtables, because they must be called in different ways.

Therefore, even though dyn Bar implements Foo, it is not possible to turn a &dyn Bar into a &dyn Foo.

Although slices (the other kind of unsized type) are not implemented using vtables, pointers to them are still fat, so the same limitation applies to impl Foo for [i32].

In some cases, you can use CoerceUnsized (only on nightly as of Rust 1.36) to express bounds like “must be coercible to &dyn FooTrait“. Unfortunately, I don’t see how to apply this in your case.

See also

More Related Contents:

  1. The trait cannot be made into an object
  2. What is the cited problem with using generic type parameters in trait objects?
  3. “Expected type parameter” error in the constructor of a generic struct
  4. How do I require a generic type implement an operation like Add, Sub, Mul, or Div in a generic function?
  5. How to write a trait bound for adding two references of a generic type?
  6. How do I use integer number literals when using generic types?
  7. How do I write the lifetimes for references in a type constraint when one of them is a local reference?
  8. How can I avoid a ripple effect from changing a concrete struct to generic?
  9. Why does a generic method inside a trait require trait object to be sized?
  10. Conflicting implementations of trait in Rust
  11. How do I return a Filter iterator from a function?
  12. Matching a generic parameter to an associated type in an impl
  13. Why can’t I use a key function that returns a reference when sorting a vector with sort_by_key?
  14. Generics Error: expected type parameter, found struct
  15. Why can’t I add a blanket impl on a trait with a type parameter?
  16. Can I avoid eager ambiguity resolution for trait implementations with generics?
  17. What does the question mark mean in a type parameter bound?
  18. What does it mean to instantiate a Rust generic with an underscore?
  19. Writing a generic function that takes an iterable container as parameter in Rust
  20. How do I unwrap an arbitrary number of nested Option types?
  21. Unable to create a polymorphic type because the trait cannot be made into an object
  22. Is List a subclass of List? Why are Java generics not implicitly polymorphic?
  23. Why doesn’t the example compile, aka how does (co-, contra-, and in-) variance work?
  24. Vector of objects belonging to a trait
  25. TypeScript: self-referencing return type for static methods in inheriting classes
  26. Generic repository in ASP.NET Core without having a separate AddScoped line per table in Startup.cs?
  27. Understanding Traits and Object Safety
  28. How to get generic parameter class in Kotlin
  29. Swift equivalent for MIN and MAX macros
  30. How do I write this member constraint in F#?

Leave a Comment