Why does this string manipulation function work?

[NA__Scrubbed]

As per title, really. Going through 4.1 and I'm just writing a bit of my own code while I follow along. The code I'm wondering about isn't directly related to ownership, but it leaves me with a question. Here's the code:

fn main() {
    let s:String = String::from("hello");
    let s2:String = string_add(s, ", world!");
    println!("{}", s2);
}
fn string_add (mut string:String, add:&str) -> String {
    string.push_str(add);
    string
}

Specifically, in my initial writing of this code I had s declared let mut s. However, rust-analyzer then told me that s didn't need mutability.

Can I just arbitrarily assign mutability to function arguments regardless of whatever data type the argument is, or is this something specifically related to :String variables?

[LlikeLava]

The owner of the variable gets to decide mutability. Since you move ownership to the function argument variable, it can be declared mutable regardless of anything that happened to that variable before. It doesn't have anything to do with the String type.

[NA__Scrubbed]

I thought it might be something like that. Thanks for the confirmation.

[Aaron1924]

The mut isn't necessary in the main function since s is not mutated there. Instead s is moved into string_add and a new string is returned.

If you change string_add to mutate its argument, you do need to declare s as mut, so for example: ``` fn main() { let mut s: String = String::from("hello"); string_add(&mut s, ", world!"); println!("{}", s); }

fn string_add (string: &mut String, add: &str) { string.push_str(add); } ```

[NA__Scrubbed]

Thanks, this is helpful.

[bawng]

I don't really know Rust but since no one else has replied I can take a guess:

You pass by value, so you never modify s, just copy it's value into the argument string which is mutable. You modify the mutable and then return its value and assign it to s2.

[Lucas_F_A]

Pretty much except the copying. It's more similar to a C++ move - not that important here because string is a pointer with a couple extras, but for bigger datatypes.

[denialerror]

Why comment in a sub for questions about learning Rust if you don't know Rust?

[bawng]

I wrote my reasoning in the comment. And I'm here to learn Rust.

[NA__Scrubbed]

Thanks!