我想知道当两个或多个不同的枚举类型具有相同的数据成员或相同的函数时，是否有一种方法可以简化以下模式匹配臂。

（如果没有，最好解释一下原因）

UPDATE:

根据要求提供我想要的更准确的示例（请原谅我将数据成员访问与函数混淆）（):

struct Point<T> {
    x: i32,
    y: T,
}

enum Record {
    V4(Point<i64>),
    V6(Point<i32>),
}

fn get_record() -> Record {
    Record::V4(Point{ x: 1, y: 1})
}

fn main() {
    let x = match get_record() {
        Record::V4(r) => r.x,
        Record::V6(r) => r.x,
    };
    println!("{}", &x);

    // this will not compile
    // let rec = get_record();
    // println!("{}", rec.x);

    // this will not compile either
    // note: if V4 Point was i32 it will compile & run
    // let rec = get_record();
    // let x = match get_record() {
    //     Record::V4(r) | Record::V6(r) => r.x,
    // };
}

原帖：

use std::net::IpAddr;
use std::str::FromStr;

fn main() {
    let v4_or_v6 = IpAddr::from_str("1.2.3.4").unwrap();

    // match expression, both arms only differ by 1 char
    let s = match v4_or_v6 {
        IpAddr::V4(ip) => ip.to_string(),
        IpAddr::V6(ip) => ip.to_string(),
    };
    println!("{}", &s);

    // not working:
    // let s2 = match v4_or_v6 {
    //     IpAddr::V4(ip) | IpAddr::V6(ip) => ip.to_string(),
    // };
    // println!("{}", &s2);
}

我了解底层的调用to_string()有不同的实现Ipv4 than Ipv6但我认为编译器可以足够聪明来处理这个问题（我错了吗？）

尝试使用注释掉的代码进行编译会导致编译错误（):

Compiling playground v0.0.1 (/playground)

error[E0308]: mismatched types
  --> src/main.rs:16:37
   |
16 |         IpAddr::V4(ip) | IpAddr::V6(ip) => ip.to_string(),
   |                                     ^^ expected struct `std::net::Ipv4Addr`, found struct `std::net::Ipv6Addr`
   |
   = note: expected type `std::net::Ipv4Addr`
              found type `std::net::Ipv6Addr`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0308`.
error: Could not compile `playground`.

工作代码脱糖为：

let s = match v4_or_v6 {
    IpAddr::V4(ip) => <Ipv4Addr as ToString>::to_string(&ip),
    IpAddr::V6(ip) => <Ipv6Addr as ToString>::to_string(&ip),
};

尽管这些语句看起来相同，但它们是不同的函数，并且在每个分支中静态地知道哪个to_string将要被使用。为了让它在单个匹配臂中工作，您必须以某种方式从模式匹配中生成一个特征对象，以便每个ip具有相同的类型（即&dyn ToString）。目前还没有办法做到这一点，而且我还没有看到任何类似的提案。

看到相同的匹配臂是很常见的，每个臂上调用相同的特征方法，即使在rustc项目。目前情况就是这样。

如果你有一个enum如果每个变体都拥有实现相同特征的类型，那么在enum并委托给内部类型。如果你没有特征，但你的类型有共同的结构（如x, y更新后的帖子结构中的字段），那么您可以在enum:

impl Record {
    fn x(&self) -> i32 {
        match self {
            Record::V4(Point { x, .. }) => *x,
            Record::V6(Point { x, .. }) => *x,
        }
    }
}

虽然这基本上是同一件事，但这意味着您可以编写一次，而不是需要访问的任何地方x:

let rec = get_record();
let x = get_record().x();

注意IpAddr已经这样做了，所以在你的原始代码中，你可以避免match总共：

let s = v4_or_v6.to_string();