如何在IntoParallelIterator约束下避免可变与不可变借用冲突？

我需要实现一个操作Vec<T>的函数，利用现有元素的引用生成新元素来扩展向量，并尝试用Rayon并行执行新元素的生成逻辑。以下是最小化示例代码：

use itertools::Itertools;
use rayon::prelude::*;

fn main() {
    let mut foo = Foo {
        data: (0..1000).into_iter().collect(),
    };
    foo.run();
}

struct Foo<T> {
    data: Vec<T>,
}

type Pair<'a, T> = (&'a T, &'a T);

impl<'a, T: Clone + 'a> Foo<T>
where
    Vec<Pair<'a, T>>: IntoParallelIterator<Item = Pair<'a, T>>,
    [T; 2]: IntoParallelIterator,
    Vec<T>: FromParallelIterator<<[T; 2] as IntoParallelIterator>::Item>,
{
    fn run(&'a mut self) {
        let combinations: Vec<Pair<'a, T>> = self
            .data
            .iter()
            .combinations(2)
            .map(|x| (x[0], x[1]))
            .collect();

        let mut new_combinations: Vec<T> = combinations
            .into_par_iter()
            .flat_map(|(a, b)| bar(a, b))
            .collect();

        self.data.append(&mut new_combinations);
    }
}

fn bar<T: Clone>(a: &T, b: &T) -> [T; 2] {
    [a.clone(), b.clone()]
}

编译时触发以下错误：

error[E0502]: cannot borrow `self.data` as mutable because it is also borrowed as immutable
  --> src/main.rs:36:9
   |
17 |   impl<'a, T: Clone + 'a> Foo<T>
   |        -- lifetime `'a` defined here
...
24 |           let combinations: Vec<Pair<'a, T>> = self
   |  ___________________________----------------___-
   | |                           |
   | |                           type annotation requires that `self.data` is borrowed for `'a`
25 | |             .data
26 | |             .iter()
   | |___________________- immutable borrow occurs here
...
36 |           self.data.append(&mut new_combinations);
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ mutable borrow occurs here

我理解最终生成的new_combinations是独立的T实例，理论上不应持有self.data的引用，应该可以可变借用self.data来追加元素，但self.data被impl上的'a生命周期绑定，导致借用范围覆盖整个方法。目前的临时方案是从方法返回new_combinations再单独追加，但希望能直接在方法内完成，同时尽量减少collect()的使用，直接通过迭代器实现。

问题根源 #

你错误地在impl块上声明了生命周期'a，并将其同时绑定到self的可变借用和Pair中的引用。这会让编译器认为self.data的不可变借用要持续整个'a生命周期（即整个方法执行期间），导致后续无法进行可变借用。实际上，combinations中的引用只需要在生成new_combinations的过程中有效，不需要与self的生命周期绑定。

修复步骤 #

1. 移除impl块上的显式生命周期：让编译器自动推导局部变量的生命周期，避免将self的借用与引用长期绑定。
2. 简化泛型约束：Rayon对Vec的IntoParallelIterator有默认实现，无需手动添加复杂约束。
3. 优化元素追加方式：使用extend替代append，无需将new_combinations转为可变引用，代码更简洁。

修改后的代码 #

use itertools::Itertools;
use rayon::prelude::*;

fn main() {
    let mut foo = Foo {
        data: (0..1000).into_iter().collect(),
    };
    foo.run();
}

struct Foo<T> {
    data: Vec<T>,
}

impl<T: Clone> Foo<T> {
    fn run(&mut self) {
        // 收集元素对的引用，生命周期由编译器自动推导为局部有效
        let combinations: Vec<(&T, &T)> = self
            .data
            .iter()
            .combinations(2)
            .map(|x| (x[0], x[1]))
            .collect();

        // 并行生成新元素，此时引用被消费，生成独立的T实例
        let new_combinations: Vec<T> = combinations
            .into_par_iter()
            .flat_map(|(a, b)| bar(a, b))
            .collect();

        // 不可变借用已结束，安全追加新元素
        self.data.extend(new_combinations);
    }
}

fn bar<T: Clone>(a: &T, b: &T) -> [T; 2] {
    [a.clone(), b.clone()]
}

关于减少collect()的优化 #

由于itertools的combinations返回的是顺序迭代器，目前无法直接转为并行迭代器，因此必须先收集到Vec中才能用Rayon并行处理。这一步的collect()暂时无法避免，但后续的并行处理流程已经是最优的——直接通过into_par_iter消费Vec，无需额外复制。

为什么这样可行？ #

编译器会自动推导combinations中引用的生命周期仅覆盖从iter()到new_combinations.collect()的过程。当new_combinations生成完成后，所有指向self.data的引用都已失效，此时self.data可以被安全地可变借用进行追加操作。

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