在Rust中生成具有递归函数的树结构时，多个可变借用

我在实现一个递归函数时遇到了麻烦，该函数通过操纵索引到不可变列表的可变索引列表来生成二叉树 .

这是代码：

enum Tree<'r, T:'r> {                                                                                                                                                                                     
    Node(Box<Tree<'r, T>>,                                                                                                                                                                                
         &'r T,                                                                                                                                                                                           
         Box<Tree<'r, T>>),                                                                                                                                                                               
    Empty                                                                                                                                                                                                 
}                                                                                                                                                                                                         

fn process_elements<T>(xs: &mut [T]) {
    // interesting things happen here                                                                                                                                                                     
}

// This function creates a tree of references to elements in a list 'xs' by                                                                                                                               
// generating a permutation 'indices' of a list of indices into 'xs',                                                                                                                                  
// creating a tree node out of the center element, then recursively building                                                                                                                              
// the new node's left and right subtrees out of the elements to the left and                                                                                                                             
// right of the center element.                                                                                                                                                                           
fn build_tree<'r, T>(xs: &'r [T],
                     indices: &'r mut [uint]) -> Box<Tree<'r, T>> {
    let n = xs.len();
    if n == 0 { return box Empty; }
    process_elements(indices);
    let pivot_index = n / 2;
    let left_subtree =
        // BORROW 1 ~~~v
        build_tree(xs, indices.slice_to_or_fail_mut(&pivot_index));
    let right_subtree =
        // BORROW 2 ~~~v
        build_tree(xs, indices.slice_from_or_fail_mut(&(pivot_index + 1)));
    box Node(left_subtree, &xs[pivot_index], right_subtree)
}

当我尝试编译它时，我得到一个错误，说我不能一次多次使用 *indices 可变，其中第一次借用发生在标记为 BORROW 1 的注释中，第二次借用发生在 BORROW 2 处 .

我清楚地看到 *points 确实在这两个位置都被借用了，但在我看来， *points 的第一次借用应该只持续到 let left_subtree 语句中对 build_tree 的单个递归调用的结束 . 但是，Rust声称这种借用实际上持续到整个 build_tree 函数结束 .

谁能解释一下：

• 为什么第一次借用持续到 build_tree 函数结束，并且

• 如何在Rust中正确实现这样的函数？

顺便说一句：如果我删除"let left_subtree ="和"let right_subtree ="（即，仅对 indices 的副作用使用 build_tree 的递归调用并将 None 传递给 Node 构造函数），代码编译得很好并且不会抱怨多次借用 . 为什么是这样？