What does it mean to implement a trait for another trait?

Question

I read this answer but I'm still confused.

1. How do you interpret impl B for dyn A {}?

   trait A {
       fn method_a(&self) {
           println!("a");
       }
   }
   
   trait B {
       fn method_b(&self) {
           println!("b")
       }
   }
   
   impl B for dyn A {}
   
   impl A for i32 {}
   
   fn main() {
       let x: &dyn A = &10;
       x.method_b();
   }
   

   Playground

   I can understand impl A for i32 {} because i32 is a concrete type. dyn A is not a concrete type (unsized, can't pass by value), and you cannot declare a dyn A but you can only declare a &dyn A. Should I interpret

   // x.method_b();
   (*x).method_b();
   

   as *x is dyn A?

2. I can also declare impl B for &dyn A {}, so why I need impl B for dyn A {}? What's the use case?

3. Follow up: If I modify the code

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

   It will fail and complain &dyn A is not &dyn B. I understand this is a reasonable complain but I provide the option for compiler to use impl B for dyn A {}. Apparently, the compiler doesn't consider that's an option.

Answer 1

You can't declare dyn A but you can declare &dyn A because dyn A is a trait object type while &dyn A is a pointer to an instance of type T that implements A.

Historically, a trait could be used as a type and a trait. For instance, these both work:

// Where B and A are traits
impl B for A {}
impl B for dyn A {}

Basically, dyn A is just a sugar over A to make it clearer that it is meant to be used as a trait object type. You don't implement a trait for another trait. You implement a trait for another trait object type.

&dyn A is a pointer instance to an instance of type T that implements A and a virtual method table (vtable), which contains all the baggage of methods of A that T implements. This vtable lookup is necessary when an instance of type T later calls A's implementation at runtime.

Therefore, dyn A is an unsized type while &dyn A is a pointer with a known size.

Trait object of type dyn A must be cast from a pointer to be used as a concrete type that implements A. For example, in the code example, i32 can be cast to a dyn A:

impl B for dyn A {}

impl A for i32 {}

fn main() {
    let x: i32 = 10;
    (&x as &dyn A).method_a(); 
    (&x as &dyn A).method_b();
}

or it can be coerced by a function:

fn dispatch(a: &dyn A) {
    a.method_b();
}

Because traits are dynamically sized types (DSTs), to use them as trait objects, we must put them behind some kind of pointer, like &dyn A or Box<dyn A> so it can point to a variable-sized value and access the vtable to call the implemented methods.

See also: What makes something a “trait object”?