Understanding `&mut &'a self` Calls on Temporaries in Rust

Jazz Thumyat 🦀 — Fri, 26 Jun 2026 13:25:04 +0000

[T] has the following split_off method. Notice that its receiver type is &mut &'a Self:

pub fn split_off<'a, R: OneSidedRange<usize>>(
    self: &mut &'a Self,
    range: R,
) -> Option<&'a Self> {
    // ...
}

Now look at this code:

let v = vec![1, 2, 3, 4, 5];
let head = v.as_slice().split_off(..2);

assert_eq!(head, Some([1, 2].as_slice()));

This may look confusing at first.

v.as_slice() returns &[i32], but split_off() expects &mut &[i32]. So where does the mutable reference come from?

The answer is that v.as_slice() creates a temporary value. In Rust, a temporary is a mutable place, so the compiler can automatically borrow it as &mut.

You can think of the code as if the compiler had written this:

let mut temp = v.as_slice();
temp.split_off(..2);

The mutable reference is taken to the temporary variable (temp), not to the original vector or slice. The vector v and the slice it produces are never mutated. Only the temporary variable is.

Proof that temporaries are mutable places

A normal let binding is immutable unless you write mut. Because of that, the following code does not compile:

let s: &[i32] = v.as_slice(); // no `mut`
let _ = s.split_off(..2);     // compiler error here

The compiler reports:

error[E0596]: cannot borrow `s` as mutable, as it is not declared as mutable
13 |     let _ = s.split_off(..2);
   |             ^ cannot borrow as mutable
help: consider changing this to be mutable
12 |     let mut s: &[i32] = v.as_slice();

This shows the difference:

let s: &[i32] = v.as_slice() creates an immutable place, so Rust cannot take &mut s.
v.as_slice() creates a temporary, and a temporary is a mutable place, so Rust can automatically take &mut to call split_off().

That is why v.as_slice().split_off(..2) compiles, while s.split_off(..2) does not unless s is declared with mut.

Expected Option, Got Option<()> — Here's Why

Jazz Thumyat 🦀 — Thu, 25 Jun 2026 04:24:16 +0000

I'm learning Rust and recently ran into something unexpected with Option type. I expected r to be Option<&mut String>, but it came back as Option<()> instead.

Here's what I tried:

let mut vds = VecDeque::from(["a".to_owned(), "b".to_owned()]);  
let r = vds  
    .get_mut(0)  
    .and_then(|v| Some(*v = String::from("Hello")));

It turned out to be a fundamental Rust concept: assignment is an expression, and it always evaluates to (), the empty unit type.

Here's why: *v = String::from("Hello") is an assignment, so it evaluates to (). Some() wraps that unit value, giving us Some(()). That's why r ends up as Option<()>.

DEV Community: Jazz Thumyat 🦀

Understanding `&mut &'a self` Calls on Temporaries in Rust

Proof that temporaries are mutable places

Expected Option, Got Option<()> — Here's Why