Join does not work on borrowed Strings

[fugu13]

I tried this code:

let errors = vec![&String::from("hi"), &String::from("world")];
let combined = errors.join(" ");

(This is a contrived example, of course, what I was really doing was borrowing from inside a parsed data structure, which led to the &Strings).

I expected to see this happen: the strings to join together, just as if they were &str or String

Instead, this happened: I received the following error

error[E0599]: the method `join` exists for struct `Vec<&std::string::String>`, but its trait bounds were not satisfied
   --> src/main.rs:103:35
    |
103 |             let combined = errors.join(" ; ");
    |                                   ^^^^ method cannot be called on `Vec<&std::string::String>` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `<[&std::string::String] as Join<_>>::Output = _`

(Which took me a good while to work out what I needed to do even looking at the source code for Join and such, as this was extremely opaque to someone fairly new to Rust).

Meta

rustc --version --verbose:

rustc 1.52.0-nightly (35dbef235 2021-03-02)
binary: rustc
commit-hash: 35dbef235048f9a2939dc20effe083ca483c37ff
commit-date: 2021-03-02
host: x86_64-apple-darwin
release: 1.52.0-nightly
LLVM version: 11.0.1

Backtrace

error[E0599]: the method `join` exists for struct `Vec<&std::string::String>`, but its trait bounds were not satisfied
   --> src/main.rs:103:35
    |
103 |             let combined = errors.join(" ; ");
    |                                   ^^^^ method cannot be called on `Vec<&std::string::String>` due to unsatisfied trait bounds
    |
    = note: the following trait bounds were not satisfied:
            `<[&std::string::String] as Join<_>>::Output = _`

[estebank]

Adding the following impl would make the code as written work (expect for a borrow checker error requiring the Strings to be bound to a local variable):

impl<'a> Borrow<str> for &'a String {
    #[inline]
    fn borrow(&self) -> &str {
        &self[..]
    }
}

The diagnostic should still be improved to mention that <[&std::string::String] as Join<_>> requires &String: Borrow<str>, which doesn't exist. With good enough wording this might be enough to unblock people, but the current output is nowhere enough for a newcomer to understand what the problem is.

[dhdaines]

Hi ... so, as a newcomer to Rust, I simply cannot figure out what the correct thing to do to avoid this error message is. Since this is where Google takes me first, could someone be so kind as to explain here what the right way to join borrowed Strings is? For example if I have two strings coming from command-line parsing with clap, how would one fix this code?

use clap::Parser;

#[derive(Parser)]
struct Cli {
    str1: String,
    str2: String,
}

fn main() {
    let c = Cli::parse();
    println!("{}", [&c.str1, &c.str2].join(","));
}

EDIT: Oh, okay... it's just [c.str1.as_str(), c.str2.as_str()] ... no idea if this is a good and efficient way to do this. The error message really ought to be more helpful :(

[estebank]

Current output for the above:

error[E0599]: the method `join` exists for array `[&String; 2]`, but its trait bounds were not satisfied
 --> src/main.rs:4:29
  |
4 |     println!("{}", [&a, &b].join(","));
  |                             ^^^^ method cannot be called on `[&String; 2]` due to unsatisfied trait bounds
  |
  = note: the following trait bounds were not satisfied:
          `[&String]: Join<_>`