为实现本地trait的类型提供Debug/Display默认实现的问题

我定义了一个包含name()方法的本地trait：

pub trait Something {
    fn name() -> &'static str;
}

我希望为所有实现该trait的类型提供Debug和Display的默认实现，让这两个trait的输出直接复用Something的name()方法。尝试的方案1如下，但触发了孤儿规则相关错误：

pub trait Something: std::fmt::Debug {
    fn name() -> &'static str;
}
impl<S:Something> std::fmt::Debug for S { // 错误：类型参数`S`必须用作某个本地类型的类型参数
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write(f, "{}", S::name())
    }
}
struct Test1 {}
impl Test1 {
    fn name() -> &'static str { "TestA" }
}

我知道Something是本地trait，应该有合法的解决途径，但不清楚具体怎么做。

Rust的孤儿规则核心要求：实现外部trait时，类型或trait必须至少有一个是本地定义的。你尝试的全局实现impl<S: Something> Debug for S之所以失败，是因为S可以是任意类型（包括外部 crate 或标准库的类型），而Debug是外部trait，这种全局实现违反了规则。

以下是几种可行的解决方式：

1. 为Something提供默认fmt方法，手动推导实现 #

这是最直接的方案，在Something中定义通用的格式化逻辑，然后让每个实现Something的类型手动复用该逻辑实现Debug和Display：

use std::fmt;

pub trait Something {
    fn name() -> &'static str;

    // 定义通用的格式化逻辑
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write(f, "{}", Self::name())
    }
}

// 示例类型实现Something
struct Test1 {}
impl Something for Test1 {
    fn name() -> &'static str { "TestA" }
}

// 手动复用Something的fmt实现Debug和Display
impl fmt::Debug for Test1 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Something::fmt(self, f)
    }
}

impl fmt::Display for Test1 {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        Something::fmt(self, f)
    }
}

fn main() {
    let test = Test1 {};
    println!("{:?}", test); // 输出 TestA
    println!("{}", test);   // 输出 TestA
}

2. 使用新类型（Newtype）包装 #

如果你想避免为每个类型手动写Debug/Display，可以用新类型包装目标类型，然后为包装后的类型实现所需trait：

use std::fmt;

pub trait Something {
    fn name() -> &'static str;
}

// 定义新类型包装任意实现Something的类型
struct Named<T>(T);

// 为新类型实现Debug
impl<T: Something> fmt::Debug for Named<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write(f, "{}", T::name())
    }
}

// 为新类型实现Display
impl<T: Something> fmt::Display for Named<T> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write(f, "{}", T::name())
    }
}

// 示例类型实现Something
struct Test1 {}
impl Something for Test1 {
    fn name() -> &'static str { "TestA" }
}

fn main() {
    let wrapped_test = Named(Test1 {});
    println!("{:?}", wrapped_test); // 输出 TestA
    println!("{}", wrapped_test);   // 输出 TestA
}

3. 派生宏（进阶方案） #

如果需要为大量本地类型自动生成实现，可以编写一个派生宏，让类型在实现Something时自动派生Debug和Display。这需要用到proc-macro crate，示例骨架如下：

// 在proc-macro crate中定义派生宏
use proc_macro::TokenStream;
use quote::quote;
use syn::{parse_macro_input, DeriveInput};

#[proc_macro_derive(NamedDebugDisplay)]
pub fn derive_named_debug_display(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let name = input.ident;
    
    let expanded = quote! {
        impl std::fmt::Debug for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write(f, "{}", <#name as Something>::name())
            }
        }
        
        impl std::fmt::Display for #name {
            fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                write(f, "{}", <#name as Something>::name())
            }
        }
    };
    
    expanded.into()
}

使用时只需在类型上添加#[derive(NamedDebugDisplay)]并实现Something即可自动获得Debug和Display实现。

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