Rust mut Before a Variable Name vs After the Colon Explained

By the end of this page, you will understand that Rust uses mut in two different roles:

• mut foo: T makes the binding mutable, meaning the local variable foo can be reassigned or used in ways that require a mutable binding.
• foo: &mut T means the type is a mutable reference, so the function receives permission to mutate the value being borrowed.

These look similar, but they solve different problems. One changes how the local name behaves, and the other changes what kind of value is being passed in.

Rust separates two ideas that many beginners initially combine:

1. Is the variable binding mutable?
2. Is the value being accessed through a mutable reference?

These are not the same thing.

1. mut foo: T means a mutable binding

When mut appears before a parameter or variable name, it applies to the binding.

fn example(mut x: i32) {
    x += 1;
}

Here, x is a local variable inside the function. Marking it mut means:

• you can reassign x
• you can call operations that require mutable access to the binding

This does not mean the caller's original value becomes mutable. Parameters are passed into the function, and mut only affects the local binding inside that function.

2. foo: &mut T means a mutable reference type

When mut appears as part of &mut T, it is part of the .

Think of Rust mutability as two separate labels:

Label 1: Can I move or change this handle?

This is the binding:

mut foo: T

Imagine foo is a labeled handle in your hand. If the handle is mutable, you can change how you use that handle, such as reassigning it.

Label 2: Does this handle let me edit the thing it points to?

This is the reference type:

foo: &mut T

Now imagine the handle points to a box in a storage room. A normal reference is like a viewing pass. A mutable reference is like an editing pass.

So:

• mut foo: T = the local handle is changeable
• foo: &mut T = the handle gives write access to the underlying value

You can even combine them:

fn example(mut x: &mut i32) {
    *x += 1;
}

This means:

• x is a mutable reference to an i32

Core syntax

Mutable binding

fn add_one(mut x: i32) {
    x += 1;
    println!("{x}");
}

x is a local mutable variable inside the function.

Mutable reference type

fn add_one(x: &mut i32) {
    *x += 1;
}

x is a mutable reference, so the function can modify the original value.

Owned value with mutable binding

fn update_box(mut b: Box<i32>) {
    *b += 1;
    println!("{}", *b);
}

b is owned by the function. Since the binding is mutable, the value inside the box can be changed through mutable dereferencing.

Borrowed value with mutable reference

Consider this example:

fn add_to_box(mut b: Box<i32>) {
    *b += 1;
    println!("inside function: {}", *b);
}

fn add_to_ref(x: &mut i32) {
    *x += 1;
    println!("inside function: {}", *x);
}

fn main() {
    let boxed = Box::new(5);
    add_to_box(boxed);

    let mut value = 5;
    add_to_ref(&mut value);
    println!("after function: {}", value);
}

What happens in add_to_box

1. boxed is created

let boxed = Box::();

When mut variable: T is used

This is common when a function takes ownership of a value and modifies it before returning or consuming it.

Examples

• Updating an owned String before returning it
• Modifying a Vec<T> passed by value
• Working with Box<T> or custom structs the function owns
• Reassigning a parameter during processing

fn normalize(mut name: String) -> String {
    name.make_ascii_lowercase();
    name
}

When value: &mut T is used

This is common when a function should modify existing data without taking ownership.

Examples

• Updating a counter
• Appending to a shared buffer
• Mutating a struct passed from caller code
• In-place parsing, formatting, or transformation

fn increment(counter: &mut i32) {
    *counter += 1;
}

In real Rust projects, developers choose between mutable bindings and mutable references based on ownership design.

Common pattern: mutate owned input, then return it

fn add_suffix(mut s: String) -> String {
    s.push_str("_done");
    s
}

This is useful in pipelines where ownership is being transferred anyway.

Common pattern: in-place mutation via &mut

fn reset_flag(flag: &mut bool) {
    *flag = false;
}

This avoids moving ownership and makes the function's intent explicit.

Common pattern: mutating struct fields

struct Config {
    debug: bool,
}

fn enable_debug(config: &mut Config) {
    config.debug = true;
}

Guarding APIs with borrowing rules

A function that takes &mut T clearly says:

Mistake 1: Thinking mut always means the same thing

Many beginners assume all mut keywords do the same job.

fn a(mut x: i32) {}
fn b(x: &mut i32) {}

These are different:

• mut x changes the binding
• &mut i32 changes the reference type

Mistake 2: Trying to write foo: mut T

This is invalid for normal parameter types.

fn broken(x: mut String) {}

Use this instead:

fn fixed(mut x: String) {}

Mistake 3: Forgetting that &mut changes the caller's value

Quick rules

• mut name: T = mutable binding
• name: &mut T = mutable reference type
• name: mut T = invalid syntax for ordinary types

Common patterns

fn a(mut x: i32) {
    x += 1;
}

fn b(x: &mut i32) {
    *x += 1;
}

fn c(mut s: String) -> String {
    s.push('!');
    s
}

fn d(s: &mut String) {
    s.push('!');
}

What each means

• mut x means the local variable x can change
• &mut T means the function can mutate the referenced T

Why is mut foo: T different from foo: &mut T in Rust?

mut foo: T makes the local parameter binding mutable. foo: &mut T means the function receives a mutable reference and can modify the borrowed value.

Can I write foo: mut Box<i32> in Rust?

No. That is not valid Rust syntax. For a mutable binding, write mut foo: Box<i32>.

Does mut foo: T let a function change the caller's original value?

Not by itself. It only makes the local owned binding mutable inside the function.

Why can *foo += 1 work with mut foo: Box<i32>?

Because the function owns the Box<i32>, and the binding is mutable, so Rust allows mutable access to the boxed value.

Do I need mut before a parameter name if the type is &mut T?

Usually no. &mut T already allows mutation of the referenced value. Add mut before the name only if you need to reassign the local parameter variable itself.

• Ownership — This explains why passing Box<i32> by value moves ownership into the function.
• Borrowing — &mut T is part of Rust's borrowing system.
• References — Understanding &T and &mut T is essential here.
• Variable bindings — mut foo applies to the binding, not directly to the type.
• Dereferencing — Expressions like *foo += 1 rely on dereferencing.
• Box — Box is an owned smart pointer, which helps explain the first example.
• Function parameters in Rust — Parameters are patterns plus types, which explains why mut appears before the name.
• Pattern syntax — Function parameters use pattern syntax, so mut foo is a mutable binding pattern.