如何对内部类型相同的Rust枚举变体统一执行相同操作？

先看这个常见的Rust错误枚举场景：

#[derive(Debug, strum::AsRefStr)]
pub enum ClientError {
    FilePathNotExist(String),
    UnableToCreateFile(String),
    UnableToCreateDirectory(String),
    ReceiverNotExist(String),
    CannotEstablishConnection(String),
    AuthenticationFailed,
    ServerDisconnected,
}

impl Display for ClientError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        use ClientError::*;
        let literal = self.as_ref().red();
        let mut info = |info: &str| write!(f, "{literal}: {}", info.yellow());
        match self {
            FilePathNotExist(path) => info(path),
            UnableToCreateFile(path) => info(path),
            UnableToCreateDirectory(path) => info(path),
            ReceiverNotExist(receiver) => info(receiver),
            CannotEstablishConnection(addr) => info(addr),
            _ => write!(f, "{literal}"),
        }
    }
}

问题核心：这个枚举的变体仅存在几种关联数据模式——无参数、单个String、多个String（示例未包含但可能扩展），每种模式对应固定格式化逻辑：

• 无参数：write!(f, "{literal}")
• 单个String：write!(f, "{literal}: {}", arg1.yellow())
• 多个String：write!(f, "{literal}: {}, {}", arg1.yellow(), arg2.yellow())

当前Match分支存在大量重复，后续新增同模式变体还需重复编写分支。假设对Rust宏不熟悉，以下是几种最优雅的去重方法：

方法一：模式匹配分组+直接格式化 #

针对现有枚举结构，把所有带单个String参数的变体用|归为一组，无参数变体单独分组，直接减少分支数量：

impl Display for ClientError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let literal = self.as_ref().red();
        match self {
            ClientError::FilePathNotExist(path)
            | ClientError::UnableToCreateFile(path)
            | ClientError::UnableToCreateDirectory(path)
            | ClientError::ReceiverNotExist(path)
            | ClientError::CannotEstablishConnection(path) => {
                write!(f, "{literal}: {}", path.yellow())
            }
            ClientError::AuthenticationFailed | ClientError::ServerDisconnected => {
                write!(f, "{literal}")
            }
        }
    }
}

这种方法完全无需宏，逻辑直白，新增同模式变体时仅需在对应分组添加一行即可。

方法二：提取关联数据到统一接口（支持多参数扩展） #

如果后续要支持多String参数的变体，可给枚举添加辅助方法提取关联数据为切片，再统一处理格式化：

impl ClientError {
    // 提取所有关联的字符串参数为切片
    fn args(&self) -> &[&str] {
        match self {
            ClientError::FilePathNotExist(path) => &[path],
            ClientError::UnableToCreateFile(path) => &[path],
            ClientError::UnableToCreateDirectory(path) => &[path],
            ClientError::ReceiverNotExist(path) => &[path],
            ClientError::CannotEstablishConnection(path) => &[path],
            // 示例：新增双参数变体的处理
            // ClientError::InvalidInput(arg1, arg2) => &[arg1, arg2],
            _ => &[],
        }
    }
}

impl Display for ClientError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let literal = self.as_ref().red();
        let args = self.args();
        
        match args.len() {
            0 => write!(f, "{literal}"),
            1 => write!(f, "{literal}: {}", args[0].yellow()),
            2 => write!(f, "{literal}: {}, {}", args[0].yellow(), args[1].yellow()),
            // 处理更多参数的通用情况
            _ => write!(f, "{literal}: {:?}", args.iter().map(|s| s.yellow()).collect::<Vec<_>>()),
        }
    }
}

这种方法将关联数据提取与格式化逻辑解耦，新增变体仅需修改args方法，格式化逻辑无需变动，扩展性更强。

方法三：借助strum库简化实现（半自动化） #

既然已经在用strum，可以利用strum_macros的Display属性自动生成基础Display逻辑，再包装颜色处理：
首先确保Cargo依赖：

strum = { version = "0.25", features = ["derive"] }
strum_macros = "0.25"

修改枚举与Display实现：

use strum::{AsRefStr, Display};
use strum_macros::Display;

#[derive(Debug, AsRefStr, Display)]
pub enum ClientError {
    #[display("{0}")]
    FilePathNotExist(String),
    #[display("{0}")]
    UnableToCreateFile(String),
    #[display("{0}")]
    UnableToCreateDirectory(String),
    #[display("{0}")]
    ReceiverNotExist(String),
    #[display("{0}")]
    CannotEstablishConnection(String),
    AuthenticationFailed,
    ServerDisconnected,
}

impl std::fmt::Display for ClientError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        let base_content = format!("{}", self); // 调用strum生成的基础Display
        let literal = self.as_ref().red();
        
        if base_content.is_empty() {
            write!(f, "{literal}")
        } else {
            write!(f, "{literal}: {}", base_content.yellow())
        }
    }
}

如果不需要颜色，直接#[derive(Display)]就能完全替代手写的Display实现，连Match分支都不用写。

内容的提问来源于stack exchange，提问作者realzhujunhao