impl-only-use

This RFC gives Rust the syntax:

```rust
use foo::FooTrait as _;
```

Here, `_` means that we want to import the `FooTrait` trait’s impls but
not the trait symbol directly, because we might declare the same symbol
in the moduling issuing the `use`.

Author: hadronized

text/0000-impl-only-use.md

@@ -0,0 +1,107 @@
+- Feature Name: impl-only-use
+- Start Date: 2017-10-01
+- RFC PR:
+- Rust Issue:
+
+# Summary
+[summary]: #summary
+
+The `use … (… as …)` syntax can now accept a wildcard `_` as alias to a trait to only import the
+implementations of such a trait.
+
+# Motivation
+[motivation]: #motivation
+
+Sometimes, we might need to `use` a trait to be able to use its methods on a type in our code.
+However, we might also not want to import the trait symbol (because we redefine it, for instance):
+
+```rust
+// in zoo.rs
+pub trait Zoo {
+  fn zoo(&self) -> u32;
+}
+
+// several impls here
+// …
+```
+
+```rust
+// in main.rs
+struct Zoo {
+  // …
+}
+
+fn main() {
+  let x = "foo";
+  let y = x.zoo(); // won’t compile because `zoo::Zoo` not in scope
+}
+```
+
+To solve this, we need to import the trait:
+
+```rust
+// in main.rs
+use zoo::Zoo;
+
+struct Zoo { // wait, what happens here?
+  // …
+}
+
+fn main() {
+  let x = "foo";
+  let y = x.zoo(); // won’t compile because `zoo::Zoo` not in scope
+}
+```
+
+However, you can see that we’ll hit a problem here, because we define an ambiguous symbol. We have
+two solutions:
+
+- Change the name of the `struct` to something else.
+- Qualified the `use`.
+
+The problem is that if we qualify the `use`, what name do we give the trait? We’re not even
+referring to it directly.
+
+```rust
+use zoo::Zoo as ZooTrait;
+```
+
+This will work but seems a bit like a hack because rustc forces us to give a name to something we
+won’t use in our types.
+
+This RFC suggests to solve this by adding the possibility to explictly state that we won’t directly
+refer to that trait, but we want the impls:
+
+```rust
+use zoo::Zoo as _;
+```
+
+# Guide-level explanation
+[guide-level-explanation]: #guide-level-explanation
+
+Qualifying a `use` with `_` on a trait imports the trait’s `impl`s but not the symbol directly. It’s
+handy if you don’t use the trait’s symbol in your type and if you redefine the symbol to something
+else.
+
+The `_` means that you “don’t care about the name rustc will use for that qualified `use`“.
+
+# Reference-level explanation
+[reference-level-explanation]: #reference-level-explanation
+
+To be defined.
+
+# Drawbacks
+[drawbacks]: #drawbacks
+
+This RFC tries to solve a very specific problem (when you *must* alias a trait use). It’s just a
+nit to make the syntax more *“rust-ish”* (it’s very easy to think such a thing would work given the
+way `_` works pretty much everywhere else.
+
+# Rationale and alternatives
+[alternatives]: #alternatives
+
+The simple alternative is to let the programmer give a name to the qualified import, which is not a
+big deal, but is a bit ugly.
+
+# Unresolved questions
+[unresolved]: #unresolved-questions