Discourage trait bounds on data structures unless necessary

[dtolnay]

Example from flate2:

pub struct EncoderReader<R: Read> {
    inner: EncoderReaderBuf<BufReader<R>>,
}

Bounds like this are annoying because they transitively infect any structs containing this type. Usually trait bounds should go just on impl blocks, not on data structures.

There are two exceptions where trait bounds on data structures are required.

1. The data structure refers to an associated type of the trait. Cow is an example of this.
2. The data structure has a Drop impl that requires trait bounds. Rust currently requires all bounds on the Drop impl to also be present on the data structure.

Relevant flate2 issue: rust-lang/flate2-rs#88

[brson]

cc https://github.com/Manishearth/rust-clippy/issues/1689

[brson]

Mention the traits where bounds on types are desirable and why. Subtle issue.

[brson]

"Flexibility" section.

[KodrAus]

I'm looking at writing this one up. So, from a pure data vs behaviour split it seems like structures should only have trait bounds that inform data, that is associated types, makes sense. Of course with the exception of Drop.

One argument that's been raised is that trait bounds on structures can communicate that a structure has no use if its inner value doesn't implement a particular trait. Most examples I've seen for this are wrapper types around something like Read. I would still lean towards not requiring the bound on the type because that's still informing behavior rather than data and limiting your future options for extensibility.

Should we note that for build-in derives you don't need to add the bound yourself? Ie:

#[derive(Debug, Clone, Hash)]
struct Foo<T: Debug + Clone + Hash>(T);

is redundant?

[KodrAus]

And I guess there's also the un-bound ?Sized to consider.