如何让Rust枚举变体使用自身实现的特征进行比较？

我在学习Rust时，以实现优先级队列作为练手项目，核心代码如下：

struct PriorityQueue {
    vec: Vec<(Thing, String)>,
}

impl PriorityQueue {
    fn push(&mut self, element: (Thing, &str)) {
        let mut inserted = false;
        for (index, inserted_element) in self.vec.iter().enumerate() {
            let (priority, _) = inserted_element;
            if element.0 < *priority {
                self.vec.insert(index, (element.0, String::from(element.1)));
                inserted = true;
                break;
            }
        }
        if inserted == false {
            self.vec.insert(self.vec.len(), (element.0, String::from(element.1)));
        }
    }

    fn pop(&mut self) -> (Thing, String) {
        self.vec.remove(0)
    }
}

优先级用Thing枚举表示，包含三种变体：

enum Thing {
    Usize(usize),
    NegInf,
    PosInf,
}

我已经为NegInf和PosInf实现了与usize的比较特征，单独测试NegInf < 3可以正常通过，但测试Thing::NegInf < Thing::Usize(3)时直接失败。测试代码如下：

#[test]
fn test_priority_queue_insert_elements_as_intended() {
    let mut priority_queue = PriorityQueue { vec: vec![] };
    assert!((NegInf < 3)); // 正常运行
    assert!((Thing::NegInf < Thing::Usize(3))); // 运行失败
    //priority_queue.push((Thing::NegInf, "negative infinite"));
    priority_queue.push((Thing::Usize(1000), "one thousand"));
    priority_queue.push((Thing::Usize(10), "ten"));
    priority_queue.push((Thing::Usize(3), "three"));
    //priority_queue.push((Thing::PosInf, "positive infinite"));
    priority_queue.push((Thing::Usize(100), "one hundred"));

    //assert_eq!(priority_queue.pop(), (Thing::NegInf, String::from("negative infinite")));
    assert_eq!(priority_queue.pop(), (Thing::Usize(3), String::from("three")));
    assert_eq!(priority_queue.pop(), (Thing::Usize(10), String::from("ten")));
    assert_eq!(priority_queue.pop(), (Thing::Usize(100), String::from("one hundred")));
    assert_eq!(priority_queue.pop(), (Thing::Usize(1000), String::from("one thousand")));
    //assert_eq!(priority_queue.pop(), (Thing::PosInf, String::from("positive infinite")));
}

运行cargo test时的报错信息：

thread 'priority_queue::tests::test_priority_queue_insert_elements_as_intended' panicked at src/priority_queue.rs:146:9:
assertion failed: (Thing::NegInf < Thing::Usize(3))

我希望Rust能自动处理不同枚举变体的比较逻辑，或者用其他内置类型联合体工具来避免这类问题。

解决方案 #

问题根源在于：你只实现了枚举变体与usize的比较，但没有为Thing枚举本身实现跨变体的比较特征。Rust不会自动推导枚举不同变体间的比较规则，必须手动为Thing实现PartialOrd和PartialEq（以及Ord、Eq如果需要全序支持）。

以下是完整的实现代码：

use std::cmp::Ordering;

enum Thing {
    Usize(usize),
    NegInf,
    PosInf,
}

// 实现相等性判断
impl PartialEq for Thing {
    fn eq(&self, other: &Self) -> bool {
        match (self, other) {
            (Thing::Usize(a), Thing::Usize(b)) => a == b,
            (Thing::NegInf, Thing::NegInf) => true,
            (Thing::PosInf, Thing::PosInf) => true,
            _ => false,
        }
    }
}

// 实现部分比较
impl PartialOrd for Thing {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        match (self, other) {
            // 负无穷小于所有其他类型
            (Thing::NegInf, _) => Some(Ordering::Less),
            // 任何类型都小于正无穷
            (_, Thing::PosInf) => Some(Ordering::Less),
            // 正无穷大于所有其他类型
            (Thing::PosInf, _) => Some(Ordering::Greater),
            // 任何类型都大于负无穷
            (_, Thing::NegInf) => Some(Ordering::Greater),
            // 两个Usize变体直接比较内部值
            (Thing::Usize(a), Thing::Usize(b)) => a.partial_cmp(b),
        }
    }
}

// 如果需要全序比较（比如用于BTreeMap等场景），补充实现Ord和Eq
impl Eq for Thing {}

impl Ord for Thing {
    fn cmp(&self, other: &Self) -> Ordering {
        self.partial_cmp(other).unwrap()
    }
}

补充说明 #

• 实现PartialOrd时必须覆盖所有变体的组合情况，确保每种可能的比较都有明确的逻辑；
• PartialOrd依赖PartialEq，因此必须同时实现这两个trait；
• 如果不想手动写枚举比较逻辑，也可以考虑用第三方 crate（比如ordered-float）结合浮点数来表示包含无穷的优先级，但如果必须基于usize，手动实现枚举比较是最直接的方案。

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