如何让泛型函数适配特定形状的元组结构体（无需Trait）

Rust本身没有内置的泛型约束语法能直接限定“类型是包含单个u8字段的元组结构体”，所以完全不添加任何Trait的话，没法直接实现这种泛型适配。不过可以通过几种极简方式大幅减少样板代码，接近你想要的效果：

方法1：自定义Trait+宏自动实现 #

先定义一个极简的Trait，再用宏批量为所有目标结构体实现它，避免重复写代码：

// 定义一个只负责提取u8的Trait
trait AsU8 {
    fn as_u8(&self) -> u8;
}

// 宏：批量为元组结构体实现AsU8
macro_rules! impl_as_u8 {
    ($($struct_name:ident),*) => {
        $(
            impl AsU8 for $struct_name {
                fn as_u8(&self) -> u8 {
                    self.0
                }
            }
        )*
    };
}

// 你的元组结构体
struct A(u8);
struct B(u8);

// 用宏批量实现Trait
impl_as_u8!(A, B);

// 泛型函数
fn foo<T: AsU8>(new_u8: T) {
    println!("{}", new_u8.as_u8() + 1);
}

fn main() {
    foo(A(10)); // 输出11
    foo(B(20)); // 输出21
}

方法2：利用标准库Deref Trait #

借助标准库的Deref，可以直接通过解引用操作获取内部的u8，手动实现的代码量也很少：

use std::ops::Deref;

struct A(u8);
struct B(u8);

// 为A实现Deref
impl Deref for A {
    type Target = u8;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

// 为B实现Deref
impl Deref for B {
    type Target = u8;
    fn deref(&self) -> &Self::Target {
        &self.0
    }
}

// 泛型函数：约束T可以解引用为u8
fn foo<T: Deref<Target = u8>>(new_u8: T) {
    println!("{}", *new_u8 + 1);
}

fn main() {
    foo(A(10));
    foo(B(20));
}

如果不想手动写Deref的实现，可以用derive_more crate的Deref derive宏，连impl代码都省了：

use derive_more::Deref;

#[derive(Deref)]
struct A(u8);

#[derive(Deref)]
struct B(u8);

fn foo<T: Deref<Target = u8>>(new_u8: T) {
    println!("{}", *new_u8 + 1);
}

方法3：利用From/Into Trait #

通过实现From（会自动获得Into的实现），可以把结构体转换成u8：

struct A(u8);
struct B(u8);

impl From<A> for u8 {
    fn from(a: A) -> u8 {
        a.0
    }
}

impl From<B> for u8 {
    fn from(b: B) -> u8 {
        b.0
    }
}

// 泛型函数：约束T可以转换成u8
fn foo<T: Into<u8>>(new_u8: T) {
    println!("{}", new_u8.into() + 1);
}

这些方法都能让你用泛型函数同时适配A和B类型，且样板代码极少，完全可以替代“无Trait”的需求。

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