Are there any other std traits where this is commonly needed? A small downside with this example is that this is something that should just be written u32::from(my_thing) 🙂

It could be a thing with Debug vs Display::fmt. That said, <Self as fmt::Debug>::fmt(self, f) is semantically identical, longer, and weirder than fmt::Debug::fmt(self, f). io::Write::write_fmt and fmt::Write::write_fmt have the same problem.

Into<T> is nice since it's reasonably likely that users will encounter a message from rustc that they should use the fully-qualified path as in these docs (though by all rights, it should suggest that you should use T::from(self)).

An other option would be to make a contrived exampled like is done in the Rust book. E.g.,

struct Person;
trait MetalHead {
 fn head_bang();
}
trait SalaryWorker {
 fn head_bang();
}
impl MetalHead for Person { ... }
impl SalaryWorker for Person { ... }
// 9 to 5
<Person as SalaryWorker>::head_bang();
// 5 to 9
<Person as MetalHead>::head_bang();

But of course coming up with a more useful example is hard since associated items don't usually overlap and there's usually sufficient type information to remove the ambiguity this doc is trying to highlight. The optimal example would be either a pair of trait methods that return a generic type like Into::<T>::into, or a pair of static trait methods. Short of what's here already, I can't find anything like that.

I've changed it so there's a footnote saying that it'd be better to use T::from(my_thing) and that the example is imperfect.

Just a small nit.

Happy to make this change, but isn't this a bit less useful? As it was, it tells you exactly which syntactic objects this syntax can be used with, whereas the change demands that you know about the associated item abstraction. Realistically, if I'm someone who's reading the keyword docs, I'm probably a rust beginner and probably not familiar with this abstraction.

Perhaps "a means of clarifying ambiguous associated items, i.e. methods, constants, and types. For example," would be a good compromise?

(I'm not the primary reviewer) if you end up listing the three kinds of associated item, please substitute method with function or with function (includes methods). Methods are only a subset of associated functions.

(Revisiting this after seeing #143098)

This paragraph is placed in the middle of the as casts explainer. E.g., below it continues to talk about as _ which is confusing and disrupts the flow. Please move it to the bottom.

Furthermore, I think we should quickly mention associated items in the synopsis / introductory paragraph to give this more structure.