Why does calling .to_string() on a String avoid a move error? Isn't it a no-op?

Question

The following test program would not compile:

fn f1( string: String) {
    println!("{}", string );
}

fn f2( string: String) {
    println!("{}", string );
}

fn main() {
    let my_string: String = "ABCDE".to_string();
    f1( my_string );
    f2( my_string );
}

It generates the well-expected error:

11 |     f1( my_string );
   |         --------- value moved here
12 |     f2( my_string );
   |         ^^^^^^^^^ value used here after move

However, if you treat my_string with the to_string() method, the program compiles and works. to_string() should be a no-op method since my_string is a String already. However, this programs works fine.

fn f1( string: String) {
    println!("{}", string );
}

fn f2( string: String) {
    println!("{}", string );
}

fn main() {
    let my_string: String = "ABCDE".to_string();
    f1( my_string.to_string() );
    f2( my_string.to_string() );
}

How does the rust theory explain this paradox?

Passing `my_string` by value moves it. Calling `my_string.to_string()` only borrows the string and returns a different string as a copy. — alter_igel, Dec 15 '22 at 16:29
@alter_igel: thank you. Yes, it must be correct because I can replace ```to_string()``` with ```clone()``` and get the same effect. Why you don't make it the answer so I will accept it. Add a comment that ```to_string()``` and ```clone()``` are equivalent in this case? — Kalle Svensson, Dec 15 '22 at 16:36

score 5 · Accepted Answer · answered Dec 15 '22 at 16:36

5

The ToString::to_string method requires a &str, which is Copy, therefore it can be moved out while keeping ownership (because &T: Copy for T: ?Sized, see the documentation).

On the other hand, String does not implement Copy, which means once the value is moved, its ownership has been given away.

answered Dec 15 '22 at 16:36

jthulhu

7,223
2
16
33

2

Essentially, `to_string()` for `String` is the same as calling `clone()`. – Chayim Friedman Dec 15 '22 at 16:49

score 0 · Answer 2 · answered Dec 23 '22 at 17:22

The answer is that to_string() applied to a String is not a no-op; it is equivalent to clone(). The clone returned by to_string() is moved, whereas the original String is only borrowed for cloning and is never moved.

I approve jthulhu's answer even though I'm not sure it points out the actual reason for the behavior.

Why does calling .to_string() on a String avoid a move error? Isn't it a no-op?

2 Answers2

Linked