У меня возникли проблемы с реализацией рекурсивной функции, которая генерирует двоичное дерево, манипулируя изменяемым списком индексов, которые индексируются в неизменяемый список.

Вот код:

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 должно длиться только до конца этого единственного рекурсивного вызоваbuild_tree вlet left_subtree заявление. Тем не менее, Руст утверждает, что этот заем фактически длится до конца всегоbuild_tree функция.

Может кто-нибудь объяснить, пожалуйста:

Почему первый заем длится до концаbuild_tree функция иКак такая функция может быть правильно реализована в Rust?

Между прочим: если я удаляю "let left_subtree =" и "let right_subtree =" (то есть, использую рекурсивные вызовы дляbuild_tree только за их побочные эффекты наindices и передатьNoneсNode конструктор), код компилируется просто отлично и не жалуется на множественные заимствования. Почему это?