Add checklist item about blanket implementations of traits

[bluss]

For each public trait in a crate, we need to consider if the blanket implementations over references and boxes (see below) should exist or not. This needs consideration since adding them later is a breaking change.

For example, for a trait Foo, the implementations (when each is applicable):

impl<'a, T> Foo for &'a T where T: Foo + ?Sized { ... }
impl<'a, T> Foo for &'a mut T where T: Foo + ?Sized { ... }
impl<T> Foo for Box<T> where T: Foo + ?Sized { ... }

other smart pointer types don't have the same rules as &, &mut, Box, so they don't need to be considered beforehand.

[dtolnay]

Good idea. What recommendation would you make here? Always provide these impls where possible?

[bluss]

I think they should be implemented when possible.

• Adaptor-prone traits like Iterator, Read, Write do this
• Traits with just &self and &mut self methods and no other Self in other parameters can forward like this really well and should probably do so too.
• For all intents and purposes some common traits do this:
  • PartialEq: &, &mut, Box,
  • std::fmt::Display: &, &mut, Box,
  • Default: Box (the others don't make much sense)
• Some traits don't do this:
  • Index — The result is that Box<T> can be indexable through deref, but does not implement the trait.

Is there maybe a class of traits where it does not make sense? Any trait that's not widely implemented for some reason? Extension traits certainly, and maybe more.