Code Logo

HashMap Key with derive(Hash)

Published at25 Jul 2026
Created by
Rust Traits & Generics Easy 0 views
Like0

Write a Rust function that defines a Point struct deriving Hash and Eq, inserts it as a key in a HashMap with an associated value, and retrieves the value. The Hash trait enables instances to be hashed for use in hash-based data structures like HashMap and HashSet.

Using custom types as HashMap keys requires both Hash and Eq (which implies PartialEq). The Hash trait computes a hash value from the struct's fields, while Eq ensures keys can be compared for exact equality during lookup. Deriving both is straightforward: #[derive(Hash, Eq, PartialEq)]. The derived hash combines field hashes using a well-defined algorithm.

HashMap is Rust's default hash table implementation. Using custom structs as keys is common for lookup tables, caching, and memoization. The derive macros ensure that the hash and equality implementations are consistent: equal structs always produce equal hashes, which is a fundamental requirement for correct HashMap behavior.

Time complexity is O(1) average for insertion and lookup. Space complexity is O(n) for the map. The HashMap uses the SipHash algorithm by default, which provides protection against HashDoS attacks.

Edge cases include hash collisions (HashMap handles them internally), structs with floating-point fields (NaN != NaN breaks Eq requirements), and ensuring the struct fields implement both Hash and Eq for the derive to work.

Example Input & Output

Example 1
Input
(5,6,30)
Output
30
Explanation

Point(5,6) maps to 30

Example 2
Input
(3,4,20)
Output
20
Explanation

Point(3,4) maps to 20

Example 3
Input
(1,2,10)
Output
10
Explanation

Point(1,2) maps to value 10

Example 4
Input
(1,2,0)
Output
0
Explanation

Override previous value

Example 5
Input
(1,2,0)
Output
0
Explanation

Same point different value

Algorithm Flow

Recommendation Algorithm Flow for HashMap Key with derive(Hash)
Recommendation Algorithm Flow for HashMap Key with derive(Hash)

Solution Approach

use std::collections::HashMap;

#[derive(Hash, Eq, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn solution(x: i32, y: i32, val: i32) -> i32 {
    let mut map = HashMap::new();
    let p = Point { x, y };
    map.insert(p, val);
    map[&Point { x, y }]
}

Best Answers

rust - Approach 1
use std::collections::HashMap;

#[derive(Hash, Eq, PartialEq)]
struct Point {
    x: i32,
    y: i32,
}

fn solution(x: i32, y: i32, val: i32) -> i32 {
    let mut map = HashMap::new();
    let p = Point { x, y };
    map.insert(p, val);
    map[&Point { x, y }]
}