Ich habe Probleme beim Implementieren einer rekursiven Funktion, die einen Binärbaum durch Manipulieren einer veränderlichen Liste von Indizes generiert, die in eine unveränderliche Liste indiziert.

Hier ist der Code:

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)
}

Wenn ich versuche, dies zu kompilieren, erhalte ich die Fehlermeldung, dass ich nichts ausleihen kann*indices als mehrmals veränderbar, wobei die erste Ausleihe bei dem mit @ gekennzeichneten Kommentar erfolBORROW 1 und die zweite Ausleihe erfolgt umBORROW 2.

Ich sehe deutlich, dass*points wird an beiden Orten ausgeliehen, aber es scheint mir, dass die erste Ausleihe von*points sollte nur bis zum Ende dieses einzelnen rekursiven Aufrufs von @ dauebuild_tree in demlet left_subtree Erklärung. Rust behauptet jedoch, dass diese Ausleihe tatsächlich bis zum Ende des gesamtenbuild_tree Funktion.

Kann jemand bitte erklären:

Warum dauert die erste Ausleihe bis zum Ende desbuild_tree function undWie kann eine solche Funktion in Rust korrekt implementiert werden?

Übrigens: Wenn ich "let left_subtree =" und "let right_subtree =" entferne (d. H. Die rekursiven Aufrufe von @ verwenbuild_tree nur für ihre Nebenwirkungen aufindices und passNones zumNodeKonstruktor), der Code kompiliert einwandfrei und beschwert sich nicht über mehrfache Ausleihen. Warum ist das