<S: AsRef<str>> vs impl AsRef<str>

[wookietreiber]

I wasn't aware of the difference between <S: AsRef<str>> and impl AsRef<str>, original Q&A here. The answer from @jonhoo was:

<> generics are specifiable using the turbofish (e.g., client.set_quota::<String>(...)), whereas impl Trait is not. That may seem like a restriction, but in practice it allows you to ensure that "important" generics are made more explicit, whereas "simple" generics (like impl AsRef<str>) sort of fade into the background.

I wonder, how/where to include this here in the patterns repo, is this a pattern or an idiom, what name should it get?

[simonsan]

I personally would say, that it's more an idiom, as in a guideline to follow when coding, and less a method to solve a common problem.

Any proposals for a name?

[pickfire]

I think both are just methods to solve problems, I don't see why one is preferred over the other, maybe in different cases then yeah.

[rbran]

I can think in a difference between the two if used to define the function return type:

A Generic is resolved into the real type based on the caller requirements. But the impl real type is resolved based on the function body itself.

Eg:
The impl here works, because the Iterator is resolved into a std::ops::Range<u32>.

fn gen_iterator(value: u32) -> impl Iterator<Item = u32> {
    0..value
}

fn main() {
   let iterator = gen_iterator(2);
   println!("result {:?}", iterator.collect::<Vec<u32>>())
}

The Generic here don't work, because the I Generic can't be resolved into a real type.

fn gen_iterator<I: Iterator<Item = u32>>(value: u32) -> I {
    0..value
}

Even if you define the generic in the function call, the compiler will give you an error:

error[[E0308]](https://doc.rust-lang.org/stable/error-index.html#E0308): mismatched types
 --> src/main.rs:2:5
  |
1 | fn gen_iterator<I: Iterator<Item = u32>>(value: u32) -> I {
  |                 -                                       -
  |                 |                                       |
  |                 |                                       expected `I` because of return type
  |                 this type parameter                     help: consider using an impl return type: `impl Iterator<Item = u32>`
2 |     0..value
  |     ^^^^^^^^ expected type parameter `I`, found struct `std::ops::Range`
  |
  = note: expected type parameter `I`
                     found struct `std::ops::Range<u32>`

For more information about this error, try `rustc --explain E0308`.
error: could not compile `playground` due to previous error