如何为枚举变体实现Borrow trait，以字符串切片作HashMap键且不克隆？

首先得明确为什么之前的Borrow技巧在枚举这里行不通：Borrow<str>要求你的Key类型的所有实例都能返回一个&str，但Key::Binary变体显然做不到这一点。更关键的是，Borrow trait有个隐含契约：实现Borrow<T>的类型，其Hash和Eq行为必须与T完全一致——而Key::Binary的哈希/相等逻辑和str根本不沾边，强行实现会违反这个契约，导致HashMap行为异常。

下面是几种优雅的解决方案，都不需要克隆输入的&str，且只会匹配Text类型的键：

方案1：线性遍历查找（简单直观，适合小HashMap） #

如果你的HashMap规模不大，直接遍历过滤是最省心的方式，不需要额外的类型或哈希逻辑：

use std::collections::HashMap;

#[derive(PartialEq, Eq, Hash)]
enum Key {
    Text(String),
    Binary(Vec<u8>)
}

fn get_from_map(map: &HashMap<Key, i32>, key: &str) -> Option<&i32> {
    map.iter()
        .find(|(k, _)| matches!(k, Key::Text(s) && s == key))
        .map(|(_, value)| value)
}

优点：代码简洁，不需要维护额外的哈希逻辑；缺点：时间复杂度是O(n)，HashMap的O(1)查找优势完全丧失，大数据量下性能拉胯。

方案2：自定义查找类型（保留O(1)性能，适合大数据量） #

我们可以定义一个临时的查找类型，让它的哈希和相等逻辑与Key::Text完全对齐，这样就能利用HashMap的O(1)查找：

use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(PartialEq, Eq, Hash)]
enum Key {
    Text(String),
    Binary(Vec<u8>)
}

// 自定义查找用的类型，持有&str引用，无需克隆
struct LookupText<'a>(&'a str);

// 让LookupText的哈希逻辑和Key::Text一致
impl Hash for LookupText<'_> {
    fn hash<H: Hasher>(&self, state: &mut H) {
        // 这里要和Key的Hash实现匹配：如果是derive的Hash，会先哈希变体的索引（Text是第一个变体，所以是0u8）
        // 如果你手动实现了Key的Hash，这里要对应调整
        0u8.hash(state);
        self.0.hash(state);
    }
}

// 实现LookupText和Key的相等判断，只匹配Text变体
impl PartialEq<Key> for LookupText<'_> {
    fn eq(&self, other: &Key) -> bool {
        match other {
            Key::Text(s) => s == self.0,
            Key::Binary(_) => false,
        }
    }
}

// 对称实现，满足Eq的对称要求
impl PartialEq<LookupText<'_>> for Key {
    fn eq(&self, other: &LookupText<'_>) -> bool {
        match self {
            Key::Text(s) => s == other.0,
            Key::Binary(_) => false,
        }
    }
}

// 现在可以直接用LookupText作为键查找
fn get_from_map(map: &HashMap<Key, i32>, key: &str) -> Option<&i32> {
    map.get(&LookupText(key))
}

优点：保留HashMap的O(1)查找性能，无需克隆输入字符串；缺点：需要维护哈希逻辑的一致性——如果后续修改了Key的变体顺序或手动实现了Hash，必须同步修改LookupText的哈希代码。

方案3：使用raw_entry（稳定版可用，最灵活） #

从Rust 1.63开始，HashMap::raw_entry()已经稳定，它允许我们直接指定哈希值和匹配逻辑，不需要额外定义类型：

use std::collections::HashMap;
use std::hash::{Hash, Hasher};

#[derive(PartialEq, Eq, Hash)]
enum Key {
    Text(String),
    Binary(Vec<u8>)
}

fn get_from_map(map: &HashMap<Key, i32>, key: &str) -> Option<&i32> {
    // 计算与Key::Text一致的哈希值
    let mut hasher = HashMap::default_hasher();
    // 同样，这里要和Key的Hash实现匹配，derive的话先哈希变体索引0
    0u8.hash(&mut hasher);
    key.hash(&mut hasher);
    let hash_value = hasher.finish();

    // 使用raw_entry直接根据哈希和匹配条件查找
    map.raw_entry()
        .from_hash(hash_value, |k| matches!(k, Key::Text(s) && s == key))
        .map(|(_, value)| value)
}

优点：无需额外类型，同样保留O(1)性能，逻辑更紧凑；缺点：同样需要保证哈希计算与Key的Hash实现一致，否则会找不到正确的条目。

注意事项 #

如果你担心derive的Hash依赖变体顺序的问题，可以手动为Key实现Hash，用固定的标记（比如字符串"Text"、"Binary"）代替变体索引，这样哈希逻辑更稳定：

impl Hash for Key {
    fn hash<H: Hasher>(&self, state: &mut H) {
        match self {
            Key::Text(s) => {
                "Text".hash(state);
                s.hash(state);
            }
            Key::Binary(b) => {
                "Binary".hash(state);
                b.hash(state);
            }
        }
    }
}

对应的，在方案2或3的哈希计算中，把0u8.hash(state)改成"Text".hash(state)即可。

内容的提问来源于stack exchange，提问作者0rvidal