Why does a &str not coerce to a &String when using Vec::contains?

Question

A friend asked me to explain the following quirk in Rust. I was unable to, hence this question:

fn main() {
    let l: Vec<String> = Vec::new();
    //let ret = l.contains(&String::from(func())); // works
    let ret = l.contains(func());  // does not work
    println!("ret: {}", ret);
}

fn func() -> & 'static str {
    "hello"
}

Example on the Rust Playground

The compiler will complain like this:

error[E0308]: mismatched types
 --> src/main.rs:4:26
  |
4 |     let ret = l.contains(func());  // does not work
  |                          ^^^^^^ expected struct `std::string::String`, found str
  |
  = note: expected type `&std::string::String`
             found type `&'static str`

In other words, &str does not coerce with &String.

At first I thought it was to do with 'static, however that is a red herring.

The commented line fixes the example at the cost of an extra allocation.

My questions:

• Why doesn't &str coerce with &String?
• Is there a way to make the call to contains work without the extra allocation?

Answer 1

It seems that the Rust developers intend to adjust the signature of contains to allow the example posted above to work.

In some sense, this is a known bug in contains. It sounds like the fix won't allow those types to coerce, but will allow the above example to work.