Add a `replace_key_for_value` API for `HashMap`s

[cactusdualcore]

I recently ran into this. It is is actually quite simple to achieve this as a pure library user.

use hashbrown::hash_map::Entry;
use core::hash::{Hash, BuildHasher};

fn replace_key_for_value<K, V, S>(
    this: &mut HashMap<K, V, S>,
    old_key: &K,
    new_key: K,
) -> Option<V>
where
    K: Eq + Hash,
    S: BuildHasher,
{
    if old_key != &new_key
        && let Some(value) = this.remove(old_key)
    {
        match this.entry(new_key) {
            Entry::Vacant(vacant) => {
                vacant.insert(value);
            }
            Entry::Occupied(mut occupied) => {
                return Some({
                    let mut old_value = value;
                    core::mem::swap(occupied.get_mut(), &mut old_value);
                    old_value
                });
            }
        }
    }

    None
}

However, I think this is the kind of function which is useful for anybody who runs into this situation and which is much more convenient and efficient as a part of the library. As this is a pretty niche function, I understand if this is not added to the library.

[clarfonthey]

Do you have an example situation where this is useful? I'm sure there is some, but I'm having trouble thinking of any at the moment.

Specifically, I'm having trouble imagining doing this just for one-off keys and not when you'd want to just rebuild the whole map and convert all the keys.

[cactusdualcore]

I have an algorithm which unifies and infers two partial types (think A<_, C> and A<B, _> to A<B, C>). When unifying type variables (the _s), I need to do some sort of compression, so binding any of the equivalent type variables binds them all. For this I choose a canonical key for all sets of equivalent type vars.

If a variable is added to such an equivalence set, I need to move the bound value to the set's canonical key.

Specifically, I'm having trouble imagining doing this just for one-off keys and not when you'd want to just rebuild the whole map and convert all the keys.

Would work too, but requires more memory for things I don't use. After unification I never access through the old key.

[clarfonthey]

Basically, I'm wondering if it would be cleaner to offer an API to map all the keys that figures out the issue with overwriting keys for you, rather than just doing it one at a time.

Since that can also be done without allocating, but you don't need to specifically handle the loop yourself, and you don't have to worry about the overwriting issue.

[cactusdualcore]

That sounds reasonable. Personally, I need to update each key one at a time, but I assume having a pair of functions that work in tandem (and potentially reuse internal machinery) sounds plausible?