What does it mean to implement Trait for Trait?

[Jarvi-Izana]

@daboross

In rust, these two pieces of data are stored in fat pointers. Whereas &i32 is 64 bits and just contains a pointer to the i32 data, &dyn Trait is 128 bits and contains two pointers: one to the data (of whatever was cast into this pointer), and the other to the trait's vtable. dyn Trait itself is just the data behind the trait - it only has the data. The other half gets stuck into whatever the dyn Trait is behind. This is the same as other unsized things, such as [T] slices, which stick their length into whatever pointer they're behind.

Follow this model, cited from here.

// for example, the vtables for i32 and Vec<i32>
static VTABLE_FOO_FOR_I32: VTableFoo = VTableFoo { ... };

pub struct TraitObjectFoo {
    data: *mut (),
    vtable_ptr: &VTableFoo,
}

// let x: &dyn Foo = &10;
let x = TraitObjectFoo{ &10, &Vtable..}; 

1. if I understand correctly &dyn Foo is the real fat pointer, then what about dyn Foo?

Back to our example:

fn main() {
     // let x: &dyn A = &10;
     let x = TraitObjectA{ &10, &VTableAForI32 };
     // have a B trait object over dyn A since
     // dyn A implements B
     let y: &dyn B = x;
 }

2. what happens to let y: &dyn B = x;? Does it first do pattern match? &dynB match with type &dyn A, and then the compiler checks whether dyn B is implemented for dyn A (find whether the vtable is existent)?

if so, I think you are right!! Follow the above model, it should be

// let y: &dyn B = x;
// pattern match: remove the &dyn: B matches with A 
// assigning a pointer to a fat pointer which is not allowed.
y.data = x; // &dyn A
y.vtable = &VTableBForDynA;

In this way, &dyn B must construct from sized data. Not sure if my understanding is correct.