im::HashMap is not covariant over the Key type.

[maartendeprez]

When using a type with a lifetime parameter as key for im::HashMap, read-only methods like get will not accept keys with shorter lifetimes. For example:

use im::HashMap;
use std::borrow::Cow;

#[derive(Clone, Debug, Hash, PartialEq, Eq)]
struct Key<'a> {
    key1: Cow<'a, str>,
    key2: Cow<'a, str>,
}

fn main() {
    let mut map: HashMap<Key<'static>, String> = HashMap::new();
    map.insert(
        Key {
            key1: Cow::Borrowed("some key 1"),
            key2: Cow::Borrowed("some key 2"),
        },
        String::from("some value"),
    );

    let key1 = String::from("some key 1");
    let key2 = String::from("some key 2");

    eprintln!(
        "{:?}",
        map.get(&Key {
            key1: Cow::Borrowed(&key1),
            key2: Cow::Borrowed(&key2)
        })
    );
}

When compiling this, the compiler complains that key1 and key2 do not live long enough; it requires that they are borrowed for 'static, even though it seems get should only need the key being available for the duration of the function call. I believe this is due to im::HashMap being invariant over its key parameter. The same example compiles and works as expected using std::collections::HashMap.

Would it be possible to make im::HashMap covariant over the key type? Or is there a reason this is not possible?

[jneem]

I'd be interested in trying to address this in my fork; would you mind opening an issue over there?