Alternate/custom key types

Any type that implements the Eq and Hash traits can be a key in HashMap.
This includes:

  • bool (though not very useful since there is only two possible keys)
  • int, uint, and all variations thereof
  • String and &str (protip: you can have a HashMap keyed by String
    and call .get() with an &str)

Note that f32 and f64 do not implement Hash,
likely because floating-point precision errors
would make using them as hashmap keys horribly error-prone.

All collection classes implement Eq and Hash
if their contained type also respectively implements Eq and Hash.
For example, Vec<T> will implement Hash if T implements Hash.

You can easily implement Eq and Hash for a custom type with just one line:
#[derive(PartialEq, Eq, Hash)]

The compiler will do the rest. If you want more control over the details,
you can implement Eq and/or Hash yourself.
This guide will not cover the specifics of implementing Hash.

To play around with using a struct in HashMap,
let’s try making a very simple user logon system:

  1. use std::collections::HashMap;
  3. // Eq requires that you derive PartialEq on the type.
  4. #[derive(PartialEq, Eq, Hash)]
  5. struct Account<'a>{
  6.     username: &'a str,
  7.     password: &'a str,
  8. }
  10. struct AccountInfo<'a>{
  11.     name: &'a str,
  12.     email: &'a str,
  13. }
  15. type Accounts<'a> = HashMap<Account<'a>, AccountInfo<'a>>;
  17. fn try_logon<'a>(accounts: &Accounts<'a>,
  18.         username: &'a str, password: &'a str){
  19.     println!("Username: {}", username);
  20.     println!("Password: {}", password);
  21.     println!("Attempting logon...");
  23.     let logon = Account {
  24.         username: username,
  25.         password: password,
  26.     };
  28.     match accounts.get(&logon) {
  29.         Some(account_info) => {
  30.             println!("Successful logon!");
  31.             println!("Name: {}", account_info.name);
  32.             println!("Email: {}", account_info.email);
  33.         },
  34.         _ => println!("Login failed!"),
  35.     }
  36. }
  38. fn main(){
  39.     let mut accounts: Accounts = HashMap::new();
  41.     let account = Account {
  42.         username: "j.everyman",
  43.         password: "password123",
  44.     };
  46.     let account_info = AccountInfo {
  47.         name: "John Everyman",
  48.         email: "j.everyman@email.com",
  49.     };
  51.     accounts.insert(account, account_info);
  53.     try_logon(&accounts, "j.everyman", "psasword123");
  55.     try_logon(&accounts, "j.everyman", "password123");
  56. }