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

Question

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

Answer 1

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 gone¹.

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:

• What's the idiomatic way to pass by mutable value?
• What's the difference between placing "mut" before a variable name and after the ":"?

---

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.