Rust中使用范围切片创建不相交可变切片并返回的报错解决

在main函数中，通过范围切片创建单个元素的可变引用（numbers[i]）和其他元素的不可变引用迭代器是合法的——借用检查器能识别这些切片范围不相交，不会违反借用规则。但将此逻辑提取到split函数后，却触发了借用冲突错误。

问题代码 #

fn main() {
    let mut numbers = [1, 2, 3, 4, 5];

    for i in 0..numbers.len() {
        let other_values = numbers[..i]
            .iter()
            .chain(numbers[i+1..].iter());
        let sum: i32 = other_values.sum();
        numbers[i] += sum;
    }

    println!("{:?}", numbers);
}

fn split<'a>(s: &'a mut [u32], i: usize) -> (&'a mut u32, impl Iterator<Item=&'a u32>){
    let r = s[..i]
        .iter()
        .chain(s[i+1..].iter());
    (&mut s[i], r)
}

错误信息 #

error[E0502]: cannot borrow `s[_]` as mutable because it is also borrowed as immutable
  --> src/main.rs:20:6
   |
16 | fn split<'a>(s: &'a mut [u32], i: usize) -> (&'a mut u32, impl Iterator<Item=&'a u32>){
   |          -- lifetime `'a` defined here
17 |     let r = s[..i]
   |             - immutable borrow occurs here
...
20 |     (&mut s[i], r)
   |     -^^^^^^^^^----
   |     ||
   |     |mutable borrow occurs here
   |     returning this value requires that `*s` is borrowed for `'a`

修复方案 #

问题根源在于：编译器无法在split函数层面，静态证明手动拆分的切片范围不相交。我们可以借助Rust标准库提供的split_at_mut系列安全方法，让编译器明确识别引用的不相交范围，从而通过借用检查。

修改后的split函数如下：

fn split<'a>(s: &'a mut [u32], i: usize) -> (&'a mut u32, impl Iterator<Item=&'a u32> + 'a) {
    // 将切片拆分为[..i]和[i..]两个不相交的可变切片
    let (left, right) = s.split_at_mut(i);
    // 从[i..]中拆分出第一个元素（即原切片的i位置）和剩余的[i+1..]切片
    let (val, right_rest) = right.split_first_mut().unwrap();
    // 拼接左右两个不相交切片的迭代器
    let iter = left.iter().chain(right_rest.iter());
    (val, iter)
}

修复逻辑说明 #

1. split_at_mut(i)：将原可变切片拆分为[..i]（left）和[i..]（right）两个不相交的可变切片，编译器能明确这两个切片的内存范围无重叠。
2. split_first_mut()：从right切片中拆分出第一个元素的可变引用（对应原切片的i位置）和剩余的[i+1..]可变切片，同样编译器能保证这两部分不相交。
3. 迭代器拼接：将left和right_rest的不可变迭代器拼接，得到所有非i位置元素的迭代器，与val的可变引用完全不重叠，符合借用规则。

注意：split_first_mut().unwrap()是安全的，只要传入的i是合法索引（0 <= i < s.len()），right切片至少包含一个元素，不会触发panic。

内容的提问来源于stack exchange，提问作者Blue7