Así que estoy un poco atascado, tratando de fusionar dos HashMaps.

Es fácil hacerlo en línea:

fn inline() {
    let mut first_context = HashMap::new();
    first_context.insert("Hello", "World");
    let mut second_context = HashMap::new();
    second_context.insert("Hey", "There");

    let mut new_context = HashMap::new();
    for (key, value) in first_context.iter() {
        new_context.insert(*key, *value);
    }
    for (key, value) in second_context.iter() {
        new_context.insert(*key, *value);
    }
    println!("Inline:\t\t{}", new_context);
    println!("Inline:\t\t{}\t{} [Initial Maps Still Usable]", first_context, second_context);
}

Es bastante fácil hacer una función:

fn abstracted() {
    fn merge<'a>(first_context: &HashMap<&'a str, &'a str>, second_context: &HashMap<&'a str, &'a str>) -> HashMap<&'a str, &'a str> {
        let mut new_context = HashMap::new();
        for (key, value) in first_context.iter() {
            new_context.insert(*key, *value);
        }
        for (key, value) in second_context.iter() {
            new_context.insert(*key, *value);
        }
        new_context
    }

    let mut first_context = HashMap::new();
    first_context.insert("Hello", "World");
    let mut second_context = HashMap::new();
    second_context.insert("Hey", "There");

    println!("Abstracted:\t{}", merge(&first_context, &second_context));
    println!("Abstracted:\t{}\t{} [Initial Maps Still Usable]", first_context, second_context);
}

Sin embargo, parece que no puedo hacer que la versión genérica funcione:

fn generic() {
    fn merge<'a, K: Hash + Eq, V>(first_context: &HashMap<&'a K, &'a V>, second_context: &HashMap<&'a K, &'a V>) -> HashMap<&'a K, &'a V> {
        let mut new_context = HashMap::new();
        for (key, value) in first_context.iter() {
            new_context.insert(*key, *value);
        }
        for (key, value) in second_context.iter() {
            new_context.insert(*key, *value);
        }
        new_context
    }

    let mut first_context = HashMap::new();
    first_context.insert("Hello", "World");
    let mut second_context = HashMap::new();
    second_context.insert("Hey", "There");

    println!("Generic:\t{}", merge(&first_context, &second_context));
    println!("Generic:\t{}\t{} [Initial Maps Still Usable]", first_context, second_context);
}

El código anterior en play.rust-lang.org.

Compilando:

error: the trait `core::kinds::Sized` is not implemented for the type `str`

Entiendo que el compilador está confundido sobre el tamaño del valor genérico, pero no estoy seguro de por qué "str" no tiene un tamaño de memoria estricto. Sé que es un corte de cadena y no un tipo, pero aún así debería funcionar, ¿no? ¿Es esto un error?

Pensé que esta sería una función relativamente trivial. Si alguien tiene una buena solución, me encantaría aprender. En realidad, idealmente, me encantaría ver una solución con untrait Mergeable y escribir un decorador para HashMap <& K, & V>, de modo que pueda llamarlet new_context = first_context.merge(&second_context); Pero esta puede ser una pregunta diferente.