Generic Key-Value Stores

In this lesson, you’ll learn how to leverage Rust’s monomorphization to build high-performance, type-safe key-value stores that avoid the runtime cost of dynamic dispatch.

Defining the Generic Interface

When building a generic key-value store, we want to allow the user to define their own data types while maintaining strict type safety. Instead of forcing data into a generic String or Any container, we define a struct that acts as a wrapper around a collection (like HashMap), parameterized by the key type K and the value type V.

To ensure our store is useful, we must constrain K to types that can be hashed and compared, using the Hash + Eq trait bounds.

use std::collections::HashMap;
use std::hash::Hash;

pub struct KVStore<K, V> {
    data: HashMap<K, V>,
}

impl<K, V> KVStore<K, V> 
where 
    K: Hash + Eq 
{
    pub fn new() -> Self {
        Self { data: HashMap::new() }
    }

    pub fn insert(&mut self, key: K, value: V) {
        self.data.insert(key, value);
    }

    pub fn get(&self, key: &K) -> Option<&V> {
        self.data.get(key)
    }
}

Why Static Dispatch Matters Here

In many languages, a generic key-value store might rely on "type erasure," where every value is cast to a common base class or pointer. In Rust, because we use generics, the compiler performs monomorphization. When you instantiate KVStore<String, UserProfile>, the compiler generates a custom version of the methods specifically for those types.

This means there is no overhead for checking types at runtime. When you call .get(), the compiler knows exactly how to hash a String and retrieve the UserProfile pointer without extra indirection. This results in machine code that is just as fast as if you had written a store specifically for those two types alone. By parameterizing the store, we gain flexibility without sacrificing the "zero-cost abstraction" principle. You can now swap your data types freely across your application, knowing the compiler has optimized the storage engine for each specific combination.

Key Takeaway: By using generic trait bounds like Hash + Eq, we create a flexible, type-safe API that the compiler compiles into specialized, high-performance machine code for every unique key-value pair type.