Why can immutable variables be passed as arguments to functions that require mutable arguments?

user_8617507 0
Viewed 1003

Example code：

fn main() {
    let a = [1, 2, 3, 4, 5];
    reset(a);
}

fn reset(mut b: [u32; 5]) {
    b[0] = 5;
}

The variable a is an immutable array, and the reset function's parameter b is a mutable array; intuitively I need to modify a to a mutable array before I can call the reset method, but the compiler tells me that I don't need to do this, why is this?

fn main() {
    let mut a = [1, 2, 3, 4, 5];
    reset(a);
}

fn reset(mut b: [u32; 5]) {
    b[0] = 5;
}

warning: variable does not need to be mutable
 --> src/main.rs:2:9
  |
2 |     let mut a = [1, 2, 3, 4, 5];
  |         ----^
  |         |
  |         help: remove this `mut`
  |
  = note: #[warn(unused_mut)] on by default
rust mutable immutability syntax variables
1 Answers

When you pass by value, you are transferring ownership of the value. No copies of the variable are required — first main owns it, then reset owns it, then it's gone1.

In Rust, when you have ownership of a variable, you can control the mutability of it. For example, you can do this:

let a = [1, 2, 3, 4, 5];
let mut b = a;

You could also do the same thing inside of reset, although I would not do this, preferring to use the mut in the function signature:

fn reset(b: [u32; 5]) {
    let mut c = b;
    c[0] = 5;
}

See also:

1 — In this specific case, your type is an [i32; 5], which implements the Copy trait. If you attempted to use a after giving ownership to reset, then an implicit copy would be made. The value of a would appear unchanged.

user_1554230
Related