How can I implement trait B for all types that implement trait A if both traits are implemented for references?

Question

We have two traits A and B for which

1. I can trivially implement B for all types that implement A .
2. I can trivially implement A for references to any type implementing A .
3. I can trivially implement B for references to any type implementing B .

Actually doing all three leads to a conflict, because now references to types that implement A would have two implementations of B for them. One due to the impl<T: A> A for &T and one transitively due to the impl<T: A> B for T (and then the impl<T: B> B for &T .

I can't remove the impl<T: B> B for &T , because there might be types that implement B but not A

Here's an example code exhibiting the behaviour.

trait A {}
trait B {}

impl<'a, T: A> A for &'a T {}
impl<T: A> B for T {}

impl<'a, T: B> B for &'a T {}

which results in the following error:

error[E0119]: conflicting implementations of trait `B` for type `&_`:
  |
  | impl<T: A> B for T {}
  | --------------------- first implementation here
  | impl<'a, T: B> B for &'a T {}
  | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ conflicting implementation for `&_`

Is it possible to use the Rust typesystem in a way to ensure that when there is an impl B for &A , we don't create one for &B ?

Answer 1

There has been some discussion on the Rust internals forum on this topic, starting with a blog post by Nicholas Matsakis about how to handle the issue of overlapping trait implementations.

Today, (unstable) Rust has some impl specialisation , but that only works for strictly more specific impls of a more generic one.

So I think the answer is that there isn't a good way to do it today, but at some point in the future there's a good chance that Rust will evolve to allow expressing overlapping trait impls.