Rust mutable String declaration from String reference argument

Question

I have

fn main() {
    let x = String::from("12");
    fun1(&x);
}
fn fun1(in_fun: &String) {
    let mut y = _______;
    y.push_str("z");
    println!("in fun {}", y);
}

where _____ is the code for declaring y based on the argument in_fun.

At first I tried let mut y = *in_fun; which errors move occurs because '*in_fun' has type 'String', which does not implement the 'Copy' trait and also let mut y = String::from(*in_fun); which gives same error.

The thing that worked was let mut y = String::from(format!("{}", *in_fun));.

Is this the right way to declare a mutable String from &String?
Also I still don't understand why dereferencing &String with * errors? I understood *& dereferencing to returns just the value of the reference.

You have to [clone](https://doc.rust-lang.org/rust-by-example/trait/clone.html) the string. See [*The Rust Programming Language*: Understanding Ownership](https://doc.rust-lang.org/book/ch04-00-understanding-ownership.html) for more information. — Aplet123, Feb 23 '21 at 13:15
`let mut y = in_fun.clone()` works but `let mut y = *in_fun.clone()` doesn't. Isn't that thing I want to clone `String` not `&String` (as was passed in the function). — I should change my Username, Feb 23 '21 at 13:21
`in_fun.clone()` will clone the `String`. The `.clone()` method takes `self` by reference so the `String` implementation matches better than cloning the reference itself. — kmdreko, Feb 23 '21 at 13:58
@kmdreko But isn't `in_fun` passed as a `&String` rather than `String` into the function? Do methods on the thing being referenced also pass to the reference (e.g. `.clone()`)? Or do you mean modify the signature so it takes `String` instead? — I should change my Username, Feb 23 '21 at 15:20
*"Do methods on the thing being referenced also pass to the reference"* - often, but it does depend on the function signature (whether its `self` or `&self`) and what other options are available. Consider looking at [this Q&A](https://stackoverflow.com/questions/28519997/what-are-rusts-exact-auto-dereferencing-rules) that discusses how function-lookup is deduced. — kmdreko, Feb 23 '21 at 16:59

Robert Cutajar · Answer 1 · 2021-02-23T13:58:15.643

3

&String is an immutable reference. Rust is strict about this and prevents many common mishaps we people tend to run into. Dereferencing &String is not possible as it would break the guarantees of safety in rust, allowing you to modify where you only have read access. See the ownership explanation.

The function should either accept a mutable reference &mut String (then the string can be modified in place) or it needs to .clone() the string from the immutable reference.

Taking a mutable reference is more efficient than cloning, but it restricts the caller from sharing it immutably in parallel.

If the only thing you want to achieve is to print out some additional information, the best way I know of is:

fn fun1<S: std::fmt::Display>(in_fun: S) {
    println!("in fun {}z", in_fun);
}

fn main() {
    let mut x = String::from("12");
    fun1(&x);
    fun1(&mut x);
    fun1(x);
    fun1("12");
}

I use a Display trait so anything that implements will do. See the playground.

On the other hand, if you really need an owned string, then ask for it :)

fn fun1<S: Into<String>>(in_fun: S) {
    let mut y = in_fun.into();
    y.push('z');
    println!("in fun {}", y);
}

fn main() {
    let x = String::from("12");
    fun1(&x);
    fun1(x);
    fun1("12");
}

This way you can accept both &str and String and keep efficient, avoiding cloning if possible.

edited Feb 23 '21 at 13:58

answered Feb 23 '21 at 13:34

Robert Cutajar

3,181
1
30
42

Would this `let mut y = in_fun.into();` implicitly clone? – C14L Feb 23 '21 at 14:26
@C14L, not in case of `String`, for same types it is an identity function https://doc.rust-lang.org/src/core/convert/mod.rs.html#552-556 Otherwise it depends on the implementation of Into/From. `&str` has to be cloned. – Robert Cutajar Feb 23 '21 at 14:33
Interesting. But, wouldn't mutating `y` change the same data that `in_fun` also points to? – C14L Feb 23 '21 at 14:48
Ah, I was under the impression that the relationship between reference `&` and dereference `*` was like function and inverse function, s.t. f^-1(f(x)) = *&x – I should change my Username Feb 23 '21 at 15:15
1

@C14L, it will if it is an owned value, like `String`, but then it is OK because no-one else has access except the current scope, the `String` cannot be accessed any other way (safely). And if the param is `&str`, `.into()` will clone it so it is OK. – Robert Cutajar Feb 25 '21 at 15:31

score 3 · Accepted Answer · answered Feb 23 '21 at 17:08

First of all, the working code:

fn fun1(in_fun: &String) {
    let mut y = in_fun.clone();
    y.push_str("z");
    println!("in fun {}", y);
}

Or, your instincts tell you you have to dereference, so (*in_fun).clone() works just the same, but is a bit redundant. *in_fun.clone() does NOT work because it's equivalent to *(in_fun.clone()) (dereferencing the clone), which isn't what you want. The reason you don't need to dereference the reference before calling clone is because Rust's method resolution allows you to call methods of a type or access properties of a type using a reference to the type, and .clone has an &self receiver.

The reason that let mut y = *in_fun doesn't work is because this attempts to move the string out from underneath the reference, which doesn't work.

I didn't realize that `.clone()` occurred before `*`, I thought the precedence was simply left to right. — I should change my Username, Feb 25 '21 at 06:11

Rust mutable String declaration from String reference argument

2 Answers2