Recursion Rust：在递归函数中使用可变引用

我试图使用如下递归函数打印

Vec

的唯一连续子数组：

使用std:：collections:：HashSet；
fn（递归）{
如果！已打印。包含（nums）{
println！（“{：？}”，nums）；
}
已打印。插入（nums）；
如果nums.len（）>=2{
递归（&nums[0..nums.len（）-1]，已打印）；
递归（&nums[1..nums.len（）]，已打印）；
}
}
pub fn main（）{
设k=vec！[1,2,3,4,5]；
让mut已打印：HashSet=HashSet:：new（）；
递归（&k[0..]，&mut已打印）；
}

当然，正如经验丰富的Rustaceans可能已经猜到的那样，这无法编译，并出现以下错误：

error[E0499]: cannot borrow `*already_printed` as mutable more than once at a time
  --> src/main.rs:12:39
   |
3  | fn recurse<'a>(nums: &'a [i32], already_printed: &'a mut HashSet<&'a [i32]>) {
   |            -- lifetime `'a` defined here
...
11 |         recurse(&nums[0..nums.len() - 1], already_printed);
   |         --------------------------------------------------
   |         |                                 |
   |         |                                 first mutable borrow occurs here
   |         argument requires that `*already_printed` is borrowed for `'a`
12 |         recurse(&nums[1..nums.len()], already_printed);
   |                                       ^^^^^^^^^^^^^^^ second mutable borrow occurs here

error: aborting due to previous error

For more information about this error, try `rustc --explain E0499`.

---

虽然这样做有效，但这似乎放弃了编译时借用检查器提供的安全轨道。在编译时借用检查器通过的情况下，是否有一种不同的规范方法来进行如上所述的递归函数调用？

神奇的解决方案是将函数的声明更改为

fn recurse<'a, 'b>(nums: &'a [i32], already_printed: &'b mut HashSet<&'a [i32]>) {
// I just changed this lifetime -----------------------^

---

fn recurse（nums:&'a[i32]，已打印：&'b mut hashset感谢您的快速回复。
fn recurse<'a, 'b>(nums: &'a [i32], already_printed: &'b mut HashSet<&'a [i32]>) {
// I just changed this lifetime -----------------------^