Rust 错误 E0495 在闭包中使用 split_at_mut

Question

我遇到了一个“错误[E0495]：由于需求冲突，无法为自动引用推断适当的生命周期”，使用这个简单的函数：

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
}

我写了一个 playpen example 包括 unsafe 的变体 split_at_mut 确实有效。

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)
    }
}

其实我想大致这样写：

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)
}

我相信如果我简单地写出一堆就可以了

let (alpha,header) = header.split_at_mut(32);
let (gamma,header) = header.split_at_mut(16);
// ...

如果我将它们放入一个数组中，也许它会起作用。我不能让它与一个看起来更干净的闭包一起工作。

Answer 1

这是一个借贷问题：

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
}

具体来说，split_at_mut 借用了s，因此您不能也在s 被借用时赋值。

为了理解这个问题，假设我们在这里讨论的是向量，使用s: &mut Vec<T>：您可以先从Vec 借用一个切片，然后使用s 对其进行变异。

这就是 Rust 指定整个访问路径被借用的原因，而不仅仅是叶子。

---

好的，那现在呢？

正如@nox 所说，解决方案是“跳舞”：

• 将&'a mut [T] 的所有权从s 移至局部变量
• 借用这个局部变量
• 分配给s

这样，借用检查器就被安抚了，因为它知道修改s不会影响局部变量及其借用。

视情况而定，有多种方法可以将所有权移出&mut X，一些常见的方法是：

• std::mem::replace,
• std::mem::swap,
• Option::take 如果X 是Option，
• ...

在您的情况下，replace 更简单。而@nox 提供的解决方案相当简单：

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

IRC 用户nox 提供了一个明确的答案，他使用mem::replace 将需要突变的&mut [T] 首先移开：

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
}