Why I cannot use simple types as mutable reference

Question

I can use mutable reference for complicated types but not for simple data types. For example x (u32) in myfn:

fn main() {
    let mut x: u32 = 10;
    myfn(&mut x);
    println!("{}", x);
}

fn myfn(x: &mut u32) {
    x = 20;
  //^^ expected `&mut u32`, found integer
  // help: consider dereferencing here
  // to assign to the mutable borrowed piece of memory
  // *x = 20;
}

Is this happening because the simple type is always a copy? If so, why I can use the reference for immutable.

you must dereference x, so write `*x = 20`. In the future provide what error compiler gave you back. — Aleksander Krauze, Oct 11 '22 at 09:31
Very relevant: https://stackoverflow.com/questions/28587698/whats-the-difference-between-placing-mut-before-a-variable-name-and-after-the — E_net4, Oct 11 '22 at 09:49

Thomas · Accepted Answer · 2022-10-11T09:52:10.180

3

Since x is a reference inside myfn, you need to dereference it before assignment. You're not assigning to x, you're assigning to the value that x refers to:

fn myfn(x: &mut u32) {
    *x = 20;
}

The compiler even shows this solution in its error message.

Explicit dereferencing is often unnecessary, for example in method calls, thanks to the Deref trait. But if you want to assign a new value, you need the explicit * there.

edited Oct 11 '22 at 09:52

answered Oct 11 '22 at 09:32

Thomas

174,939
50
355
478

I'm reading the Rust book. I haven't reached to the dereferencing part yet. – ICE Oct 11 '22 at 09:49

Why I cannot use simple types as mutable reference

1 Answers1