I’m planning to write an RFC on named `impl`

s and I am looking for collaborators on this RFC.
If this interests you and you want to reach out for more direct conversation - you can find me on #rust-lang @ irc.mozilla.org (CET timezone mostly).

## What are named impls?

Consider a `Monoid`

trait.
For `usize`

there are more than one valid monoids:

- (usize, 1, *)
- (usize, 0, +)

But which do we `impl`

for?
Well - what if we didn’t have to pick?
With named impls, you can do:

```
mod my_mod {
extern crate frunk;
use frunk::monoid::Monoid;
impl Sum of Monoid for usize { .. }
impl Product of Monoid for usize { .. }
pub use Sum as _; // Reexports Sum as anonymous (which are all hitherto valid impls).
}
```

In another module you may then:

```
use my_mod::Product; // Imports Product into the module scope.
fn main() {
let x = <usize as my_mod::Sum>::combine(1, 2); // UFCS
let x = <usize as my_mod::Sum of Monoid>::combine(1, 2); // Equivalent
let x = usize::combine(1, 2) // refers to <usize as my_mod::Product>::combine(1, 2);
}
```

Named impls must be referred to explicitly (including via UFCS or importing explicitly), therefore there should be no backwards compatibility issues. The named impls feature is also a sound (hopefully) escape hatch out of the orphan rule.

There are plenty of issues and kinks to work out, including:

- is this always sound?
- how do we deal with trait objects?
- what is the syntax when generics are involved both for UFCS and defining impls.
- what is the syntax for associated items?
- how do we make this maximally ergonomic?

Thus I can’t promise that we will solve everything and make an RFC PR. However, it will be a fun experience =)