为类型实现Ord很尴尬？

Question

我有一个新类型，我想实现Ord：

use std::cmp::{Ord, Ordering};

struct MyType(isize);

impl Ord for MyType {
    fn cmp(&self, &other: Self) -> Ordering {
        let MyType(ref lhs) = *self;
        let MyType(ref rhs) = *other;
        lhs.cmp(rhs)
    }
}

当我尝试比较我的类型的两个变量时，会出现错误：

error[E0277]: the trait bound `MyType: std::cmp::PartialOrd` is not satisfied
 --> src/main.rs:5:6
  |
5 | impl Ord for MyType {
  |      ^^^ can't compare `MyType` with `MyType`
  |
  = help: the trait `std::cmp::PartialOrd` is not implemented for `MyType`

error[E0277]: the trait bound `MyType: std::cmp::Eq` is not satisfied
 --> src/main.rs:5:6
  |
5 | impl Ord for MyType {
  |      ^^^ the trait `std::cmp::Eq` is not implemented for `MyType`

当我实现PartialEq，Eq和PartialOrd（gt（），lt（），Eq（），ge（），le（））时，一切都很好，但如果我提供cmp，我们可以推断出lt（）和Eq（）之类的函数！这是多余的！我不喜欢这个！

当查看文档时，我在Ord的定义中看到了这一点：

pub trait Ord: Eq + PartialOrd<Self> 

这看起来像是从Eq和PartialOrd继承的特征。为什么trait不能使用cmp函数为继承的trait提供所需方法的默认实现？我不知道遗传特性是如何起作用的，搜索也没有什么用处，但我认为这应该是可能的。

这是如何在铁锈中完成的？我希望不是这样。。。

Answer 1

请将此视为原始答案的补充，适合您的具体情况。这个答案涉及你问题的第二部分。

考虑这个结构：

struct Person {
    id: u32,
    name: String,
    height: u32,
}

PartialEq特性，来自文档

Trait for equality comparisons which are partial equivalence 
relations. This trait allows for partial equality, for types that do not
have a full equivalence relation. For example, in floating point numbers
NaN != NaN, so floating point types implement PartialEq but not Eq.

Formally, the equality must be (for all a, b and c):

symmetric: a == b implies b == a; and
transitive: a == b and b == c implies a == c.

因此，如果您想表达类型的值相等意味着什么，您必须实现ParatalEq特性。实现它允许我们写x==y和x！=y为我们的类型。

impl PartialEq for Person {
    fn eq(&self, other: &Person) -> bool {
        self.height == other.height
    }
}

请注意，我们只是根据高度来确定Personstruct的相等性。如果要比较每个结构字段，也可以实现此eq方法：

fn eq(&self, other: &Person) -> bool {
     self.id == other.id && self.name == other.name && self.height == other.height
}

但是，如果您想要的是这种行为，那么简单地添加#[派生（部分Eq）]会更容易。

Eq特征，来自文档

Trait for equality comparisons which are equivalence relations.

This means, that in addition to a == b and a != b being strict inverses, 
the equality must be (for all a, b and c):

reflexive: a == a;
symmetric: a == b implies b == a; and
transitive: a == b and b == c implies a == c.

This property cannot be checked by the compiler, and therefore Eq implies
PartialEq, and has no extra methods.

Derivable
This trait can be used with #[derive]. When derived, because Eq has no extra methods, 
it is only informing the compiler that this is an equivalence relation rather than a 
partial equivalence relation. Note that the derive strategy requires all 
fields are Eq, which isn't always desired.

PartialEq用于不一定是自反的关系（也就是说，可以有这样的x，x！=x），Eq是一个标记特征，表示关系也是自反的（现在它是一个适当的等价关系）。

您还可以使用空impl块手动实现Eqtrait

impl Eq for Person {}

但是，同样，将Eq添加到#[派生（Eq）]列表更容易。

使用运算符

在实现PartialOrd之前，必须先实现PartialEq。

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

排序是具有以下值的枚举：

pub enum Ordering {
    Less,
    Equal,
    Greater,
}

partial\u cmp返回一个选项，而不是一个排序，因为有些类型的值不能总是进行比较，例如浮点数NaNs不是可表示的数字；表达式，如3.0

事实上，partial_cmp返回一个选项

在实现Ord之前，必须先实现PartialOrd、Eq和PartialEq。

对于我们的Personstruct，我们可以再次委托给我们的一个成员变量：

impl Ord for Person {
    fn cmp(&self, other: &Person) -> Ordering {
        self.height.cmp(&other.height)
    }
}

Answer 2

对于初学者，您只能实现PartialOrd:：partial_cmp，因为lt、le、gt、和ge都有默认实现。此外，如果您实现Ord，您可以像往常一样简单地实现cmp，而partial\u cmp只会变成Some（self.cmp（other））。

然而，如果您只想委托给某个字段的平等和有序概念，那么它要好得多，也更容易推导：

#[derive(PartialOrd, Ord, PartialEq, Eq)]
struct MyType(isize);

Answer 3

对于您的具体情况，我将使用#[派生]：

#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
struct MyType(isize);

fn main() {
    let a = MyType(5);
    let b = MyType(6);

    println!("{:?}", a.cmp(&b))
}

如果您需要对您的Ord实现进行特殊处理，您仍然需要写出代码，没有什么可以帮我们解决这个问题！如果这样做有意义的话，您仍然可以派生其他特性的实现。

你问题的另一部分模棱两可，因此我将从两个方面回答：

为什么使用PartialOrd的任何东西都不能自动提供Ord？

让我们看看PartialOrd和Ord的文档。

PartialOrd说：“比较必须满足反对称性和及物性”，而Ord说：“形成总顺序的类型”。这些都是数学术语，我不会像维基百科那样描述它们。

但是，我们可以使用浮点数作为示例。浮点数有一个特殊的值，称为NaN。与这个值进行比较是很棘手的。例如，所有的1.0

我们不能用PartialOrd来定义Ord，因为我们对底层类型没有适当的保证。这是Rust的类型系统，可以避免我们犯错误！

为什么使用Ord的任何东西都不能自动提供PartialOrd？

这里的问题是PartialOrd类型比Ord类型多。如果我们要求所有内容都是Ord，那么我们就不能进行任何浮点比较，因为它们没有总顺序，否则我们就不得不放弃总顺序，失去它提供的安全性。

但是，有一些想法可以自动为派生执行此操作。拟议的RFC 2385将允许将上述代码缩减为：

#[derive(Debug, Copy, Eq, Ord)]
struct MyType(isize);

当我实现PartialOrd（gt（），lt（），eq（），ge（），le（））

请注意，PartialOrd有默认实现，您只需要实现partial\u cmp。其他的是为了便于使用或可能是性能原因。