How do I implement Ord for a struct?

Question

I've seen a question similar to this one, but no one that tells me exactly how to implement Ord for a struct. For example, the following:

struct SomeNum {
    name: String,
    value: u32,
}

impl Ord for SomeNum {
    fn cmp(&self, other:&Self) -> Ordering {
        let size1 = self.value;
        let size2 = other.value;
        if size1 > size2 {
            Ordering::Less
        }
        if size1 < size2 {
            Ordering::Greater
        }
        Ordering::Equal
    }
}

This gives me the error:

error: the trait `core::cmp::Eq` is not implemented for the type `SomeNum` [E0277]

How would I fix this? I have tried changing the implementation to:

impl Ord for SomeNum where SomeNum: PartialOrd + PartialEq + Eq {...}

and adding the appropriate partial_cmp and eq functions but it gives me the error that both those methods are not a member of Ord.

Answer 1

The definition of Ord is this:

pub trait Ord: Eq + PartialOrd<Self> {
    fn cmp(&self, other: &Self) -> Ordering;
}

Any type that implements Ord must also implement Eq and PartialOrd<Self>. You must implement these traits for SomeNum.

Incidentally, your implementation looks like being the wrong way round; if self.value is all you are comparing, self.value > other.value should be Greater, not Less.

You can use the Ord implementation on u32 to assist, should you desire it: self.value.cmp(other.value).

You should also take into account that Ord is a total ordering. If your PartialEq implementation, for example, takes name into consideration, your Ord implementation must also. It might be well to use a tuple for convenience (indicating that the most important field in the comparison is value, but that if they are the same, name should be taken into account), something like this:

struct SomeNum {
    name: String,
    value: u32,
}

impl Ord for SomeNum {
    fn cmp(&self, other: &Self) -> Ordering {
        (self.value, &self.name).cmp(&(other.value, &other.name))
    }
}

impl PartialOrd for SomeNum {
    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
        Some(self.cmp(other))
    }
}

impl PartialEq for SomeNum {
    fn eq(&self, other: &Self) -> bool {
        (self.value, &self.name) == (other.value, &other.name)
    }
}

impl Eq for SomeNum { }

If you’re doing it like this, you might as well reorder the fields and use #[derive]:

#[derive(PartialEq, Eq, PartialOrd, Ord)]
struct SomeNum {
    value: u32,
    name: String,
}

This will expand to basically the same thing.