Rust error E0495 using split_at_mut in a closure - rust

Question

I'm encountering an "error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements" with this simple function:
fn assign_split_at_mut<'a, 'b, T>(s: &'b mut &'a mut [T], mid: usize) -> &'a mut [T] {
let (x, y) = (*s: &'a mut [T]).split_at_mut(mid);
*s = y;
x
}
I wrote a playpen example including this unsafe variant of split_at_mut that does work.
fn assign_split_at_mut_unsafe<'a, T>(s: &mut &'a mut [T], mid: usize) -> &'a mut [T] {
let len = (*s: &'a mut [T]).len();
let ptr = (*s: &'a mut [T]).as_mut_ptr();
unsafe {
use std::slice::from_raw_parts_mut;
assert!(mid <= len);
*s: &'a mut [T] = from_raw_parts_mut(ptr.offset(mid as isize), len - mid);
from_raw_parts_mut(ptr, mid)
}
}
In fact, I want to write roughly this:
pub fn slice_header<'a>(&'static self, mut header: &'a mut [u8])
-> MyResult<HeaderRefs<'a>>
{
// ...
let take = |l: usize| -> &'a mut [u8] {
let (x,y) = header.split_at_mut(l);
header = y; x
};
let hr = HeaderRefs {
params: self,
alpha: array_mut_ref![take(32),0,32],
gamma: array_mut_ref![take(16),32,16],
beta: take(self.beta_length as usize),
surb_log: take(self.surblog_length as usize),
surb: take(self.surb_length()),
};
// ...
Ok(hr)
}
I believe it would work fine if I simply wrote out a bunch of
let (alpha,header) = header.split_at_mut(32);
let (gamma,header) = header.split_at_mut(16);
// ...
Maybe it'd work if I put them into an array. I cannot get it to work with a closure, which would look much cleaner.

Answer 1

This is a borrowing issue:
fn assign_split_at_mut<'a, 'b, T>(s: &'b mut &'a mut [T], mid: usize) -> &'a mut [T] {
let (x, y) = (*s: &'a mut [T]).split_at_mut(mid);
*s = y;
x
}
Specifically, split_at_mut borrows s, so you cannot also assign to s while it is borrowed.
To understand the issue, imagine that we were talking about vectors here, with s: &mut Vec<T>: you could first borrow a slice from the Vec and then use s to mutate it.
This is why Rust specifies that the whole access path is borrowed, not just the leaf.
Okay, so what now?
As mentioned by #nox, the solution is to "dance":
move the ownership of &'a mut [T] out of s to a local variable
borrow this local variable
assign to s
This way, the borrow checker is appeased since it knows that modifying s cannot affect the local variable and its borrows.
There are various ways to move the ownership out of &mut X depending on the situation, some common ways are:
std::mem::replace,
std::mem::swap,
Option::take if X is an Option,
...
In your case, replace is the simpler. And the solution provided by #nox is rather simple:
fn reserve<'heap, T>(heap: &mut &'heap mut [T], len: usize) -> &'heap mut [T] {
let tmp: &'heap mut [T] = ::std::mem::replace(&mut *heap, &mut []);
let (reserved, tmp) = tmp.split_at_mut(len);
*heap = tmp;
reserved
}

Answer 2

An IRC user nox provided a clean answer by using mem::replace to move the &mut [T] that needs mutation out of the way first :
fn reserve<'heap, T>(heap: &mut &'heap mut [T], len: usize) -> &'heap mut [T] {
let tmp: &'heap mut [T] = ::std::mem::replace(&mut *heap, &mut []);
let (reserved, tmp) = tmp.split_at_mut(len);
*heap = tmp;
reserved
}