Help understanding extension trait for &Self and &mut Self references and Sized

[Yandros]

@lancegatlin

1. &mut Self in this case is of type ParserExt< E> and since there is no inheritance the compiler won’t upcast this for me.

In your example above, is there a way to cast “input” to Parser< E> ?

The main problem comes from upcasting the potentially existent dyn SubParser into a dyn Parser. Although this should be possible, it is currently not the case in Rust, since there are some unresolved issues about the precise mechanism to achieve this, see this thread and this other one.

@lancegatlin

Some Google-Fu turned up some new ideas based on above. Here is the solution I’m going with that works around the issue without spreading ?Sized everywhere:

#![deny(bare_trait_objects)]

trait ParseFrom<I,E> : Sized {
	fn parse_from (parser: &mut dyn Parser<E>, from: I) -> Result<Self,E>;
}

trait Parser<E> {
	fn as_parser_mut (&mut self) -> &mut dyn Parser<E>;
	...
}

This does indeed resolve the upcasting issue, since it adds an explicit method on the vtable in charge of performing the upcasting. It is annoying because it forces you to write the trivial implementation every time you want to implement the trait.

@lancegatlin

• &mut Parser< E> is equivalent to &mut dyn Parser< E> and is how we use dynamic dispatch on a trait object. Here &mut Parser< E> means that I expect to receive (at runtime) a dynamic instance of Parser< E> and use dynamic dispatch to call it’s methods.
• (parser: &mut impl Parser< E>, … ) is sugar for <P:Parser< E>>(parser: &mut P, …), which is static dispatch of calls to methods of parser.
• Given #1 and #2 above, I don’t see how your [following] statement is true.

@Yandros

the first argument must be a mut reference to the dyn Parser<E> trait object, i.e. , a &mut dyn Parser<E> , or something that can coerce to it: a mutable reference to a concrete type that implements Parser<E> (written &mut (impl Parser<E> + Sized) ).

My poor phrasing is to blame, here; the argument is required to be a &mut dyn Parser, which does indeed use dynamic dispatch based on a very precise vtable: dyn Parser's vtable (i.e., dyn SubParser's vtable does not do the trick here).

Now, dyn Parser implements Parser and so does dyn SubParser too. Meaning that both these types could be Self in your example, provided there is not a Self : Sized bound.

• My &mut impl Parser + ?Sized (i.e., <P : Parser + ?Sized> ... &mut P) solution on the called function allowed to solve the issue since then such function would be able to momonorphise (statically dispatch) to both the P = dyn Parser and P = dyn SubParser cases.

• And yes, it is true that having to add ?Sized for each generic is annoying it's a retrocompatibility artifact from Sized's current design not having existed at the beginning of Rust...

And when Self = dyn SubParser, &mut Self cannot be coerced to a &mut dyn Parser, since that would imply upcasting, which is not a conversion available in Rust directly; hence the requirement for a method such as as_parser_mut.

---

I hope it's clearer, now