Skip to content

Document fully-qualified syntax in as' keyword doc #142670

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wants to merge 1 commit into
base: master
Choose a base branch
from
Open

Document fully-qualified syntax in as' keyword doc #142670

Changes from all commits
Commits
Show all changes
1 commit
Select commit
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
7 changes: 7 additions & 0 deletions library/std/src/keyword_docs.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -24,6 +24,13 @@
/// (`u8`, `bool`, `str`, pointers, ...) whereas `From` and `Into` also works with types like
/// `String` or `Vec`.
///
/// You'll also find with `From` and `Into`, and indeed all traits, that `as` is used for the
/// _fully qualified path_, a means of clarifying ambiguous method calls, constants, and types.
/// If you have a type which implements two traits with identical method names (e.g.
/// `Into<u32>::into` and `Into<u64>::into`), you can clarify which method you'll use with
/// `<MyThing as Into<u32>>::into(my_thing)`. This is quite verbose, but fortunately, Rust's type
Copy link
Contributor

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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) 🙂

Copy link
Author

@fpdotmonkey fpdotmonkey Jun 19, 2025 •
edited
Loading

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

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.

/// inference usually saves you from needing this, although it is occasionally necessary.
///
/// `as` can also be used with the `_` placeholder when the destination type can be inferred. Note
/// that this can cause inference breakage and usually such code should use an explicit type for
/// both clarity and stability. This is most useful when converting pointers using `as *const _` or
Expand Down
Loading