How to get mutable references to two array elements at the same time?

Since Rust 1.26, pattern matching can be done on slices. You can use that as long as you don't have huge indices and your indices are known at compile-time.

fn change(a: &mut i32, b: &mut i32) { let c = *a; *a = *b; *b = c; } fn main() { let mut arr = [5, 6, 7, 8]; { let [ref mut a, _, ref mut b, ..] = arr; change(a, b); } assert_eq!(arr, [7, 6, 5, 8]); } 

As of Rust 1.86, there is get_disjoint_mut():

fn main() { let mut v = vec![1, 2, 3]; let [a, b] = v .get_disjoint_mut([0, 1]) .expect("out of bounds or overlapping indices"); change(a, b); } 

The borrow rules of Rust need to be checked at compilation time, that is why something like mutably borrowing a part of a Vec is a very hard problem to solve (if not impossible), and why it is not possible with Rust.

Thus, when you do something like &mut v[i], it will mutably borrow the entire vector.

Imagine I did something like

let guard = something(&mut v[i]); do_something_else(&mut v[j]); guard.do_job(); 

Here, I create an object guard that internally stores a mutable reference to v[i], and will do something with it when I call do_job().

In the meantime, I did something that changed v[j]. guard holds a mutable reference that is supposed to guarantee nothing else can modify v[i]. In this case, all is good, as long as i is different from j; if the two values are equal it is a huge violation of the borrow rules.

As the compiler cannot guarantee that i != j, it is thus forbidden.

This was a simple example, but similar cases are legions, and are why such access mutably borrows the whole container. Plus the fact that the compiler actually does not know enough about the internals of Vec to ensure that this operation is safe even if i != j.

In your precise case, you can have a look at the swap(..) method available on Vec that does the swap you are manually implementing.

On a more generic case, you'll probably need an other container. Possibilities are wrapping all the values of your Vec into a type with interior mutability, such as Cell or RefCell, or even using a completely different container, as @llogiq suggested in his answer with par-vec.

The method [T]::iter_mut() returns an iterator that can yield a mutable reference for each element in the slice. Other collections have an iter_mut method too. These methods often encapsulate unsafe code, but their interface is totally safe.

Here's a general purpose extension trait that adds a method on slices that returns mutable references to two distinct items by index:

pub trait SliceExt { type Item; fn get_two_mut(&mut self, index0: usize, index1: usize) -> (&mut Self::Item, &mut Self::Item); } impl<T> SliceExt for [T] { type Item = T; fn get_two_mut(&mut self, index0: usize, index1: usize) -> (&mut Self::Item, &mut Self::Item) { match index0.cmp(&index1) { Ordering::Less => { let mut iter = self.iter_mut(); let item0 = iter.nth(index0).unwrap(); let item1 = iter.nth(index1 - index0 - 1).unwrap(); (item0, item1) } Ordering::Equal => panic!("[T]::get_two_mut(): received same index twice ({})", index0), Ordering::Greater => { let mut iter = self.iter_mut(); let item1 = iter.nth(index1).unwrap(); let item0 = iter.nth(index0 - index1 - 1).unwrap(); (item0, item1) } } } } 

Building up on the answer by @bluss you can use split_at_mut() to create a function that can turn mutable borrow of a vector into a vector of mutable borrows of vector elements:

 fn borrow_mut_elementwise<'a, T>(v:&'a mut Vec<T>) -> Vec<&'a mut T> { let mut result:Vec<&mut T> = Vec::new(); let mut current: &mut [T]; let mut rest = &mut v[..]; while rest.len() > 0 { (current, rest) = rest.split_at_mut(1); result.push(&mut current[0]); } result } 

Then you can use it to get a binding that lets you mutate many items of original Vec at once, even while you are iterating over them (if you access them by index in your loop, not through any iterator):

 let mut items = vec![1,2,3]; let mut items_mut = borrow_mut_elementwise(&mut items); for i in 1..items_mut.len() { *items_mut[i-1] = *items_mut[i]; } println!("{:?}", items); // [2, 3, 3] 

The problem is that &mut v[…] first mutably borrows v and then gives the mutable reference to the element to the change-function.

This reddit comment has a solution to your problem.

Edit: Thanks for the heads-up, Shepmaster. par-vec is a library that allows to mutably borrow disjunct partitions of a vec.

I publish my daily utils for this to crate.io. Link to the doc.

You may use it like

use arref::array_mut_ref; let mut arr = vec![1, 2, 3, 4]; let (a, b) = array_mut_ref!(&mut arr, [1, 2]); assert_eq!(*a, 2); assert_eq!(*b, 3); let (a, b, c) = array_mut_ref!(&mut arr, [1, 2, 0]); assert_eq!(*c, 1); // ⚠️ The following code will panic. Because we borrow the same element twice. // let (a, b) = array_mut_ref!(&mut arr, [1, 1]); 

It's a simple wrapper around the following code, which is sound. But it requires that the two indexes are different at runtime.

pub fn array_mut_ref<T>(arr: &mut [T], a0: usize, a1: usize) -> (&mut T, &mut T) { assert!(a0 != a1); // SAFETY: this is safe because we know a0 != a1 unsafe { ( &mut *(&mut arr[a0] as *mut _), &mut *(&mut arr[a1] as *mut _), ) } } 

Alternatively, you may use a method that won't panic with mut_twice

#[inline] pub fn mut_twice<T>(arr: &mut [T], a0: usize, a1: usize) -> Result<(&mut T, &mut T), &mut T> { if a0 == a1 { Err(&mut arr[a0]) } else { unsafe { Ok(( &mut *(&mut arr[a0] as *mut _), &mut *(&mut arr[a1] as *mut _), )) } } } 

You could use split_at_mut, but it doesn't work as well if you need more than two indices or if the order is unknown.

This crate solves this issue in a performant way and it works for the general case (any number of requested indices): https://github.com/mcmah309/indices

fn main() { let mut v = vec![1, 2, 3]; let (zero, one) = indices::indices!(&mut v, 0, 1); change(zero, one); } 

The other options is get_many_mut on nightly, but just be aware it has to do a sort of the slice of indices you provide. Which may not be best option if you know the amount of indices, or the ordering, or the values at compile time.