Wie umgehen Sie die Umgehungsprüfung von Rust bei HashMap?

Question

Ich habe diesen Code, wo pat_vec und str_vec sind zwei Iteratoren:

let mut pat_mapping: HashMap<char, &str> = HashMap::new(); 

for combi in pat_vec.zip(str_vec) { 
    let (c, word) = combi; 

    match pat_mapping.get(&c) { 
     Some(phrase) => { 
      if phrase.to_string() != word.to_string() { 
       return false; 
      } 
     } 

     None => { 
      pat_mapping.insert(c, word); 
     } 
    } 
} 

Dies funktioniert nicht, und der Compiler beschwert sich, dass:

cannot borrow `pat_mapping` as mutable because it is also borrowed as immutable [E0502] 

Ich verstehe, dass es vielleicht weil pat_mapping.get(&c)&self als unveränderlich entlehnt , während die insert() Methode in den gleichen Bereich fällt, aber &self als veränderbar ausleihen muss.

Ich habe eine Arbeit um:

match word_mapping.get(&c) { 
    Some(phrase) => { 
     if phrase.to_string() != word.to_string() { 
      return false; 
     } 
    } 
    None => { 

     pat_trigger = true; 
    } 

}; 

if pat_trigger { 
    pat_mapping.insert(c, word); 
} 

Aber ein boolesches Flag Einführung ist überflüssig. Gibt es eine Möglichkeit, den Borrow-Check zu umgehen, um das Match durchzuführen und in denselben Codeblock einzufügen?

Answer 1

Sie wollen entry verwenden:

match pat_mapping.entry(c) { 
    Occupied(phrase) => { 
     if phrase.get().to_string() != word.to_string() { 
      return false; 
     } 
    }, 
    Vacant(vacant) => { 
     vacant.insert(word); 
    } 
} 

Es hat auch den Vorteil, dass der Schlüssel nur einmal aufzublicken.