4

I have a struct:

struct Student {
    first_name: String,
    last_name: String,
}

I want to create a Vec<Student> that can be sorted by last_name. I need to implement Ord, PartialOrd and PartialEq:

use std::cmp::Ordering;

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

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

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

This can be quite monotonous and repetitive if you have a lot of structs with an obvious field to sort by. Is it possible to create a macro to automatically implement this?

Something like:

impl_ord!(Student, Student.last_name)

I found Automatically implement traits of enclosed type for Rust newtypes (tuple structs with one field), but it's not quite what I'm looking for.

4

2 回答 2

6

是的，你可以，但首先：请阅读为什么你不应该！

为什么不？

当一个类型实现Ord或者PartialOrd它意味着这个类型有一个自然的顺序，这反过来意味着实现的顺序是唯一的逻辑顺序。取整数：3 自然小于 4。当然，还有其他有用的排序。您可以使用相反的顺序以降序对整数进行排序，但只有一种自然的顺序。

现在你有了一个由两个字符串组成的类型。有自然排序吗？我声称：不！有很多有用的排序，但是按姓氏排序比按名字排序更自然吗？我不这么认为。

那怎么办呢？

还有另外两种排序方法：

两者都允许您修改排序算法比较值的方式。按姓氏排序可以这样完成（完整代码）：

students.sort_by(|a, b| a.last_name.cmp(&b.last_name));

这样，您可以指定如何对每个方法调用进行排序。有时您可能希望按姓氏排序，而有时您希望按名字排序。由于没有明显且自然的排序方式，因此您不应将任何特定的排序方式“附加”到类型本身。

但说真的，我想要一个宏......

当然，在 Rust 中可以编写这样的宏。一旦你了解了宏观系统，这实际上很容易。但是，我们不要为您的Student示例这样做，因为- 我希望您现在已经理解- 这是一个坏主意。

什么时候是个好主意？当语义上只有一个字段是类型的一部分时。采用这个数据结构：

struct Foo {
    actual_data: String,
    _internal_cache: String,
}

在这里，_internal_cache语义上不属于您的类型。这只是一个实现细节，因此应该忽略Eqand Ord。简单的宏是：

macro_rules! impl_ord {
    ($type_name:ident, $field:ident) => {
        impl Ord for $type_name {
            fn cmp(&self, other: &$type_name) -> Ordering {
                self.$field.cmp(&other.$field)
            }
        }

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

        impl PartialEq for $type_name {
            fn eq(&self, other: &$type_name) -> bool {
                self.$field == other.$field
            }
        }

        impl Eq for $type_name {}
    }
}

为什么我把你问的这么大的代码块称为简单？好吧，这段代码的绝大部分正是您已经编写的：impls. 我执行了两个简单的步骤：

  1. 在您的代码周围添加宏定义并考虑我们需要哪些参数（type_name和field）
  2. 替换所有提及的Studentwith$type_name和所有提及的last_namewith$field

这就是为什么它被称为“示例宏”的原因：您基本上只是将普通代码编写为示例，但可以根据参数使其部分可变。

你可以在这里测试整个事情。

于 2017-08-13T20:39:06.243 回答
1

我创建了一个宏，它允许Ord通过定义用于比较元素的表达式来实现：ord_by_key::ord_eq_by_key_selector，类似于您所要求的。

use ord_by_key::ord_eq_by_key_selector;

#[ord_eq_by_key_selector(|s| &s.last_name)]
struct Student {
    first_name: String,
    last_name: String,
}

如果您必须在不同情况下按照不同的标准进行排序，您可以为您的结构引入一个容器，该容器将实现不同的排序策略：

use ord_by_key::ord_eq_by_key_selector;

struct Student {
    first_name: String,
    last_name: String,
}

#[ord_eq_by_key_selector(|(s)| &s.first_name)]
struct StudentByFirstName(Student);

#[ord_eq_by_key_selector(|(s)| &s.last_name, &s.first_name)]
struct StudentByLastNameAndFirstName(Student);
于 2020-11-17T19:04:28.300 回答