Rust中如何为相似结构体A、B实现通用From<T>转C？

我有两个结构完全相同的结构体A和B，需要将它们都转换为类型C。三者的定义如下：

pub struct A {
   pub a: i32,
}

pub struct B {
   pub a: i32,
}

pub struct C {
   pub b: i32,
}

我已经实现了从A到C的From转换：

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

因为A和B结构相似，目前我为B转C写了重复的From实现。我想实现一个仅适用于A和B的通用From<T>实现，尝试的代码如下：

trait Types {}

impl Types for A {}
impl Types for B {}

impl<T: Types> From<T> for C where T: Types {
    fn from(entity: T) -> C {
        C { b: entity.a }
    }
}

但编译时出现错误：

error[E0609]: no field `a` on type `T`
   |
27 | impl<T: Types> From<T> for C where T: Types {
   |      - type parameter 'T' declared here

必须保留A和B结构体，需要找到解决该错误、避免代码重复的方法。

方法1：定义带字段访问的特征 #

原代码的Types特征仅做类型标记，未提供访问字段a的接口，编译器无法确认所有Types类型都包含a字段。可以修改特征，添加获取a值的方法：

trait HasA {
    fn take_a(self) -> i32;
}

impl HasA for A {
    fn take_a(self) -> i32 {
        self.a
    }
}

impl HasA for B {
    fn take_a(self) -> i32 {
        self.a
    }
}

impl<T: HasA> From<T> for C {
    fn from(entity: T) -> C {
        C { b: entity.take_a() }
    }
}

通过HasA特征统一字段访问逻辑，编译器就能安全地为所有实现该特征的类型生成From转换。

方法2：用宏生成重复实现 #

如果不想引入额外特征，可使用Rust宏自动生成From实现，消除手动重复代码：

macro_rules! impl_from_to_c {
    ($($ty:ty),*) => {
        $(
            impl From<$ty> for C {
                fn from(entity: $ty) -> C {
                    C { b: entity.a }
                }
            }
        )*
    };
}

// 一次性为A和B生成From实现
impl_from_to_c!(A, B);

这种方式直接为指定类型生成对应的转换逻辑，代码简洁且无需额外依赖，适合结构简单的场景。

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