Rust：`sort_by` 多个条件，冗长的模式匹配

huangapple
go评论94阅读模式
英文:

Rust: `sort_by` multiple criteria, verbose pattern matching

问题

Here's the translated code without the translation of the code parts:

  1. 我有一个要根据以下标准排序的 `Vector` 玩家：
  3. 1. 根据 `championships`（降序）
  4. 2. 根据 `wins`（降序）
  5. 3. 根据 `name`（升序）
  7. 我在 Rust 中实现如下：
  9. ```rust
  10. use std::cmp::Ordering;
  12. #[derive(Debug)]
  13. struct Player {
  14.     name: String,
  15.     championships: u8,
  16.     wins: u8,
  17. }
  19. fn main() {
  20.     let mut players = vec![
  21.         Player {
  22.             name: "Alice".to_string(),
  23.             championships: 3,
  24.             wins: 17,
  25.         },
  26.         Player {
  27.             name: "Bob".to_string(),
  28.             championships: 3,
  29.             wins: 19,
  30.         },
  31.         Player {
  32.             name: "Claire".to_string(),
  33.             championships: 4,
  34.             wins: 18,
  35.         },
  36.         Player {
  37.             name: "Dan".to_string(),
  38.             championships: 4,
  39.             wins: 18,
  40.         },
  41.     ];
  42.     players.sort_by(|a, b| match b.championships.cmp(&a.championships) {
  43.         Ordering::Less => Ordering::Less,
  44.         Ordering::Greater => Ordering::Greater,
  45.         Ordering::Equal => match b.wins.cmp(&a.wins) {
  46.             Ordering::Less => Ordering::Less,
  47.             Ordering::Greater => Ordering::Greater,
  48.             Ordering::Equal => match a.name.cmp(&b.name) {
  49.                 Ordering::Less => Ordering::Less,
  50.                 Ordering::Greater => Ordering::Greater,
  51.                 Ordering::Equal => Ordering::Equal,
  52.             },
  53.         },
  54.     });
  55.     dbg!(players);
  56. }

这个代码按预期工作，如下所示的输出：

  1. [src/main.rs:46] players = [
  2.     Player {
  3.         name: "Claire",
  4.         championships: 4,
  5.         wins: 18,
  6.     },
  7.     Player {
  8.         name: "Dan",
  9.         championships: 4,
  10.         wins: 18,
  11.     },
  12.     Player {
  13.         name: "Bob",
  14.         championships: 3,
  15.         wins: 19,
  16.     },
  17.     Player {
  18.         name: "Alice",
  19.         championships: 3,
  20.         wins: 17,
  21.     },
  22. ]

然而，模式匹配的代码非常重复，因为在大多数情况下，我只是返回我已经得到的东西，例如：

  1. Ordering::Less => Ordering::Less,
  2. Ordering::Greater => Ordering::Greater,

有没有缩短这种冗长的方式的快捷方法？

这不是一个排序问题，而是一个模式匹配问题。（也许可以以更优雅的方式按多个标准排序，但我没有想出如何做，因为我有升序/降序的排序标准。）

  2. <details>
  3. <summary>英文:</summary>
  5. I have a `Vector` of players to be sorted by the following criteria:
  7. 1. by `championships` (descending)
  8. 2. by `wins` (descending)
  9. 3. by `name` (ascending)
  11. I implemented it as follows in Rust:
  13. ```rust
  14. use std::cmp::Ordering;
  16. #[derive(Debug)]
  17. struct Player {
  18.     name: String,
  19.     championships: u8,
  20.     wins: u8,
  21. }
  23. fn main() {
  24.     let mut players = vec![
  25.         Player {
  26.             name: &quot;Alice&quot;.to_string(),
  27.             championships: 3,
  28.             wins: 17,
  29.         },
  30.         Player {
  31.             name: &quot;Bob&quot;.to_string(),
  32.             championships: 3,
  33.             wins: 19,
  34.         },
  35.         Player {
  36.             name: &quot;Claire&quot;.to_string(),
  37.             championships: 4,
  38.             wins: 18,
  39.         },
  40.         Player {
  41.             name: &quot;Dan&quot;.to_string(),
  42.             championships: 4,
  43.             wins: 18,
  44.         },
  45.     ];
  46.     players.sort_by(|a, b| match b.championships.cmp(&amp;a.championships) {
  47.         Ordering::Less =&gt; Ordering::Less,
  48.         Ordering::Greater =&gt; Ordering::Greater,
  49.         Ordering::Equal =&gt; match b.wins.cmp(&amp;a.wins) {
  50.             Ordering::Less =&gt; Ordering::Less,
  51.             Ordering::Greater =&gt; Ordering::Greater,
  52.             Ordering::Equal =&gt; match a.name.cmp(&amp;b.name) {
  53.                 Ordering::Less =&gt; Ordering::Less,
  54.                 Ordering::Greater =&gt; Ordering::Greater,
  55.                 Ordering::Equal =&gt; Ordering::Equal,
  56.             },
  57.         },
  58.     });
  59.     dbg!(players);
  60. }

This works as intended, as the output shows:

  1. [src/main.rs:46] players = [
  2.     Player {
  3.         name: &quot;Claire&quot;,
  4.         championships: 4,
  5.         wins: 18,
  6.     },
  7.     Player {
  8.         name: &quot;Dan&quot;,
  9.         championships: 4,
  10.         wins: 18,
  11.     },
  12.     Player {
  13.         name: &quot;Bob&quot;,
  14.         championships: 3,
  15.         wins: 19,
  16.     },
  17.     Player {
  18.         name: &quot;Alice&quot;,
  19.         championships: 3,
  20.         wins: 17,
  21.     },
  22. ]

However, the pattern matching code is very repetitive, because in most cases I just return what I've already got, e.g.:

  1. Ordering::Less =&gt; Ordering::Less,
  2. Ordering::Greater =&gt; Ordering::Greater,

Is there any shortcut to avoid this kind of verbosity?

It's not really a sorting problem but a pattern matching problem. (Maybe the sorting by multiple criteria could be done in a more elegant way, which I didn't figure out how to do, given that I have ascending/descending criteria to sort by.)

答案1

得分: 5

以下是翻译好的部分：

使用类似你示例中的链式比较是 std::cmp::Ordering::then（以及 then_with） 的用法：

  1. players.sort_by(|a, b| {
  2.     b.championships
  3.         .cmp(&amp;a.championships)
  4.         .then(b.wins.cmp(&amp;a.wins))
  5.         .then(b.name.cmp(&amp;a.name).reverse())
  6. });
英文:

Chaining comparisons as in your example is what std::cmp::Ordering::then (and then_with) is for:

  1. players.sort_by(|a, b| {
  2.     b.championships
  3.         .cmp(&amp;a.championships)
  4.         .then(b.wins.cmp(&amp;a.wins))
  5.         .then(b.name.cmp(&amp;a.name).reverse())
  6. });

huangapple
  • 本文由 发表于 2023年5月22日 02:10:46
  • 转载请务必保留本文链接：https://go.coder-hub.com/76301280.html
  • match
  • rust
  • sorting
匿名

发表评论

匿名网友

:?: :razz: :sad: :evil: :!: :smile: :oops: :grin: :eek: :shock: :???: :cool: :lol: :mad: :twisted: :roll: :wink: :idea: :arrow: :neutral: :cry: :mrgreen:

确定