Suggestion to avoid wrappers with additional impl Trait construction

Just as Deref allows one conversion to a type that may implement many traits, there could be a new impl Trait syntax that allows many conversions, each to one trait. I'm thinking something like this:

impl Trait for Type byconversion {
  fn from_self(&self) -> &TypeIsTrait { ... } // if a `Trait` method has arguments with `Self` type
  fn to_self(TypeIsTrait) -> Self { ... } // if a `Trait` method has a return value with `Self` type
}

I have no opinion about the form of the syntax. The above looks like a new trait, but it would work better as an alternate form of impl (I think)

The result would be an implicit conversion every time a method of Trait is called on Type, similar to Deref, but with traits instead of types. The search for which conversion to do would be handled by the existing search over traits.

The use case is currently handled by wrapper code. For example, most of impl PartialOrd for Rc consists of lines of the form: **self op **other. These could all be replaced by a single directive to implement PartialOrd by conversion (the conversion here being a simple deref).

There might be different forms of conversion for move vs borrow vs etc. I'm not sure how much complexity that would add. I think the two above (new type from reference, new self by move) would be the most useful, and most similar to the functionality provided by Deref.

Maybe this could even be a macro, but I don't yet have experience with macros, so I don't know.

Start with the issue proposal and the repository's RFC process; no implementation files or tests are identified. Determine whether implicit trait conversions are desired, settle the move and borrow cases and syntax, and document a complete design before implementation can be considered done.