Odpowiedź.

Historia pytania

Kolekcje HashSet i HashMap to standardowe struktury z std::collections, które implementują szybkie wyszukiwanie na podstawie hasha. Są wbudowane w Rust od pierwszych wersji języka, ale wewnętrzne szczegóły ich użycia często stają się problematyczne nawet dla doświadczonych programistów z powodu systemu własności.

Problemy

Pojawiają się nieporozumienia przy dodawaniu i wyciąganiu elementów (szczególnie jeśli wartości nie są Copy), przy zmianach w kolekcji (nawiasy mutowalne) oraz przy używaniu odniesień jako kluczy. Jest także problem z implementacją poprawnych Eq/Hash dla typów użytkowników.

Rozwiązanie

Przy dodawaniu elementu kolekcja zabiera (move) klucz/wartość, jeśli nie używana jest referencja lub typ, który można skopiować.
Można bezpiecznie zmieniać zawartość tylko przez mutowalną referencję do HashMap/HashSet.

Przykład kodu:

use std::collections::HashMap;
fn main() {
    let mut map = HashMap::new();
    map.insert("key", 42);
    if let Some(value) = map.get("key") {
        println!("Znaleziono wartość: {}", value);
    }
}

Kluczowe cechy:

Klucze w HashMap/HashSet muszą implementować Hash, Eq
Dodanie elementu zawsze przenosi (move) zmienną do kolekcji
Bezpieczne wyciąganie wartości tylko wtedy, gdy kolekcja się nie zmienia (zasady pożyczki)

Pytania z pułapką.

Czy można uzyskać kilka mutowalnych referencji do tego samego elementu HashMap?

Nie, kontroler pożyczek tego nie zezwoli, aby uniknąć naruszenia własności.

Czy można używać literału ciągu "abc" bezpośrednio jako klucza HashMap<String, V>?

Nie, oczekiwany jest dokładnie String, a "abc" to &'static str. Wymagana jest konwersja: insert("abc".to_string(), val).

Czy można wyciągnąć wartość z HashMap, zachowując ją w osobnej zmiennej i kontynuować używanie HashMap?

Tak, można wziąć referencję do wartości przez get — ale jeśli wykonać remove (lub wyciągnąć przez move), HashMap mutuje, a wszelkie wcześniejsze referencje stają się nieważne.

Typowe błędy i antywzorce

Używać referencji do tymczasowego klucza przy wyszukiwaniu (żyje tyle samo co map)
Implementować Hash/Eq dla złożonych struktur bez uwzględnienia wszystkich pól (niebezpieczeństwo kolizji lub niespójnych porównań)
Zmieniać strukturę HashMap podczas iteracji przez referencje do jej wartości

Przykład z życia

Negatywny przypadek

Próba pożyczania jednocześnie klucza i wartości, a następnie modyfikacja kolekcji:

let mut map = HashMap::new();
map.insert("abc".to_string(), 10);
let val = map.get("abc");
map.insert("def".to_string(), 20); // błąd kontrolera pożyczek

Zalety:

Przejrzysty kod z perspektywy nowicjusza

Wady:

Błąd kompilacji — nie można jednocześnie pożyczać mutowalnie i niemutowalnie

Pozytywny przypadek

Wyciąganie wartości, praca tylko z jej kopią lub klonem:

let mut map = HashMap::new();
map.insert("abc".to_string(), 10);
if let Some(val) = map.get("abc") {
   let val = *val; // kopiujemy
   map.insert("def".to_string(), 20); // wszystko działa
}