Compiler help: &str -> String suggestion about to_string

[darnuria]

Note: If the discussion I suggest settle to a consensus for change I would be happy to be mentored to make a change!

I open this issue in mind that a similar issue #40762 was closed in Apr 25, 2017 but the situation has changed and also in my mind due to the state of the Rust book (details about search below).

Situation

I teach Rust to bachelors 2 students in computer science and and a Rustlings an exercise about strings involve understanding usage of String and &str, one possible outcome is to give a &str instead of a String like in this code:

fn print_with_string(s: String) {
    println!("{}", s);    
}

fn main() {
    let s = "Hello";
    print_with_string(s);
}

This result in this compiler message in rust stable:

   Compiling playground v0.0.1 (/playground)
error[E0308]: mismatched types
 --> src/main.rs:6:23
  |
6 |     print_with_string(c)
  |                       ^
  |                       |
  |                       expected struct `std::string::String`, found `&str`
  |                       help: try using a conversion method: `c.to_string()`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.

Same almost the same message in nightly.

🔎 Actual state about this in the book

• ch08-02 Strings chapter in book
• Search occurrence in book of String::from: https://doc.rust-lang.org/book/?search=String::from
• Search occurrence in book of to_string: https://doc.rust-lang.org/book/?search=to_String

Edit: Promoted this section upper in discussion to provide reference quickly.

Learning difficulty

Pointing about to_string() introduce some complexity since the new standard in book is String::from(c).

I now that a looot of historical way to convert to String exist.

List thanks to internal forum member @jethrogb:

• "hello".to_owned()
• "hello".to_string()
• String::from("hello")
• "hello".into()
• format!("hello") maybe not exactly intended for but some of my student used it in exercise I was surprised.

I found that as Rust is a difficult language (to teach/and learn), using a conventionalized way of converting remove some burden on student (also on reading), as they learn since they can get a grasp by following teaching material.

In teacher perspective explaining to learners "Okay! c.to_string() is exactly the same as String::from it's due to historical details" is not really the best experience. Bonus it hide the fact that a standardized way of converting now exist.

Actual implementation

Following @scottmcm and @estebank contribution to the discussion I added this section about what is the state in sources.
link /src/alloc/string.rs.html#2257-2262:

#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
impl ToString for str {
    #[inline]
    fn to_string(&self) -> String {
        String::from(self)
    }
}

Link [src/alloc/string.rs.html#2305-2311](<https://doc.rust-lang.org/src/alloc/string.rs.html#2305-2311):

#[stable(feature = "rust1", since = "1.0.0")]
impl From<&str> for String {
    #[inline]
    fn from(s: &str) -> String {
        s.to_owned()
    }
}

Purposed solution

I would be in favor suggesting usage of String::from, bonus it's give exposure to std::convert::From trait.

Backlog: this question seems like a real deal in learning experience and among intermediate Rustacean: https://users.rust-lang.org/t/what-is-the-idiomatic-way-to-convert-str-to-string/12160/11

Thanks for reading feel free to close if it's still not a major issue! 🎉
Edit: Fix code example.
Edit2: Improve readability by moving book link closer to the begging; add implementation links.

[estebank]

to_string() is the idiomatic way of performing this transformation, so I would prefer the suggestion remaining as is. It is true that teaching <String as From<&str>::from is useful on its own to teach how auto-deref and the From trait work, but I don't think it should be introduced early because of how much context is needed, while calling to_string() "looks" like a simple method call (although it uses ToString).

[scottmcm]

to_string() is the idiomatic way of performing this transformation

Citation? The closest thing to decision I have is https://users.rust-lang.org/t/what-is-the-idiomatic-way-to-convert-str-to-string/12160/10?u=scottmcm from carols10cents in 2017, which I think linked to roughly https://doc.rust-lang.org/1.22.0/book/second-edition/ch08-02-strings.html#creating-a-new-string back when that link worked, and that section uses String::from more than .to_string(). I'd love to have a newer link 🙃

And of course there are also other threads too, like this well-liked comment from dtolnay, which is anecdotal but has some clout as a libs team member, https://users.rust-lang.org/t/to-string-vs-to-owned-for-string-literals/1441/6?u=scottmcm

I found that my opinion on this has changed significantly over the past 12 months as I have grown more experienced with Rust.

I now strongly prefer to_owned() for string literals over either of to_string() or into().

(Personally I prefer different things based on context, but don't expect diagnostics to do that.)

---

EDIT a few days later: All that said, I think it staying .to_string() in the suggestion is fine.

[darnuria]

Thanks folks for contributing to the discussion.

@scottmcm: I provided links with search about usage of to_string and String::from as of nowday stable book in the first post.

🔎 Actual state about this in the book

• ch08-02 Strings chapter in book
• Search occurrence in book of String::from: https://doc.rust-lang.org/book/?search=String::from
• Search occurrence in book of to_string: https://doc.rust-lang.org/book/?search=to_String

Also edited first post about that is done in the sources but I would prefers that the discussion focus on on what needs to be taught to new Rustacean and not what is closest to the metal (there is #[inline] for that), if possible and if everybody agree about that point.

[estebank]

String::from and to_string() are literally the same thing, both semantically and behind the scenes. They both can be called on anything that supports Display, which has the added benefit of working on things beyond just &str, so it gives it orthogonality. There's to_owned() which used to be more performant, but I remain unconvinced that it communicates intent better than to_string(). As for which of String::from and to_string() to prefer, looking at rustc's codebase, there are ~900 uses of the former and ~6000 of the later. rustc is not necessarily a paragon of what Rust's style should be, but that ratio is replicated in another large repo I have access to. Didn't search for the alternative cases of to_owned(), into() or format! as they are more than a grep away. As an interesting stylistic cul de sac, String::from comes in handy for cases like opt_str.map(String::from). Regardless, despite my interpretation that to_string() is the most popular way of performing this conversion, I wouldn't ever block a PR over which one is used. As for changing the suggestion I am inclined not to change it only because of the already mentioned ratios and because the suggestion for String::from() would require the output to be the following, but I am not overly bothered either way:

error[E0308]: mismatched types
 --> src/main.rs:6:23
  |
6 |     print_with_string(c)
  |                       ^ expected struct `std::string::String`, found `&str`
help: try using a conversion method
  |
6 |     print_with_string(String::from(c))
  |                       ^^^^^^^^^^^^^ ^

[darnuria]

I suppose it's safe to close it since two years passed. If anybody disagree please reopen. ;)