Define static const hashmap of objects in Rust

Question

We have a static list of objects. We would like to create a static constant HashMap with the key being the names of the objects.

How do we do that?

As an example, here is the definition of a Book object:

struct Book<'a> {
    name: &'a str,
    author: &'a str,
    id: i32,
}

Here is a static list of 3 books:

const ALL_BOOKS: &'static [Book] = &[
    Book {
        name: "Zero to One",
        author: "James",
        id: 2,
    },
    Book {
        name: "Zero to One",
        author: "Tom",
        id: 1,
    },
    Book {
        name: "Turtle all the way",
        author: "Jerry",
        id: 1,
    },
];

We want to defined a dictionary of books with the key being the name of the book, and the value being a list of book with that name.

I notice that we have lazy_static from:

• Rust best practices when specifying a constant hash map
• Global mutable HashMap in a library

Here is what I tried:

lazy_static! {
    static ref ALL_BOOKS_BY_SHORT_NAME: HashMap<String, Vec<Book<'static>>> = {
        let mut map = HashMap::new();

        for book in ALL_BOOKS {
            if !map.contains_key(book.name) {
                map.insert(book.name.to_owned(), vec![book]);
            } else {
                let mut list = map.get(book.name).unwrap();
                list.push(book)
            }
        }

        map
    };
}

Here is the error:

error[E0308]: mismatched types
  --> src/main.rs:42:9
   |
30 |     static ref ALL_BOOKS_BY_SHORT_NAME: HashMap<String, Vec<Book<'static>>> = {
   |                                         ----------------------------------- expected `HashMap<String, Vec<Book<'static>>>` because of return type
...
42 |         map
   |         ^^^ expected struct `Book`, found `&Book<'_>`
   |
   = note: expected struct `HashMap<_, Vec<Book<'static>>>`
              found struct `HashMap<_, Vec<&Book<'_>>>`

What does the '_ mean here? How do we solve that?

Answer 1

The '_ is "some lifetime". The actual lifetime is 'static, but the compiler doesn't know that at this stage of the compilation.

The problem is that you're iterating over a slice of Book<'static>s. And inserting items to the map. But iteration over a slice produces references, while your maps is expecting owned Books.

The fix is simple: clone or copy the books.

#[derive(Clone, Copy)]
struct Book<'a> { ... }

lazy_static! {
    static ref ALL_BOOKS_BY_SHORT_NAME: HashMap<String, Vec<Book<'static>>> = {
        let mut map = HashMap::new();

        for book in ALL_BOOKS {
            if !map.contains_key(book.name) {
                map.insert(book.name.to_owned(), vec![*book]);
            } else {
                let mut list = map.get(book.name).unwrap();
                list.push(*book)
            }
        }

        map
    };
}

Some more notes:

• Prefer once_cell to lazy_static (its API is going to be part of std).
• Use the entry API:

use once_cell::sync::Lazy;

static ALL_BOOKS_BY_SHORT_NAME: Lazy<HashMap<String, Vec<Book<'static>>>> = Lazy::new(|| {
    let mut map = HashMap::<_, Vec<_>>::new();

    for book in ALL_BOOKS {
        map.entry(book.name.to_owned()).or_default().push(*book);
    }

    map
});

This allocates a string even for duplicate keys but given that this is only an initialization routine this likely doesn't matter.