从C++转Rust：泛型代码触发E0609错误求解答

问题重现 #

你从C++转Rust后尝试使用泛型，编写的测试代码触发了E0609错误，原代码如下：

struct FF<T1, T2>(T1, T2);

trait FFt<T1, T2> {
    type t1 = T1;
    type t2 = T2;
    fn call<t1, t2>(&self, t_1: Self::t1, t_2: Self::t2);
};

impl<T1, T2> FFt<T1, T2> for FF<T1, T1> {
    fn call<T1, T2>(&self, t_1: Self::t1, t_2: Self::t2) {
        t_1.a = 1;
        t_2.b = 1;
    }
}

struct AA {
    a: i32,
    b: i32,
}
let fff: FF<AA, AA> = FF(AA { a: 0, b: 0 }, AA { a: 0, b: 0 });

fff.call(AA { a: 0, b: 0 }, AA { a: 0, b: 0 }); // ERROR LINE !!!

编译器报错信息：

error[E0609]: no field `a` on type `T1`
   --> p2p/./src/lib.rs:172:17
    |
170 |     impl<T1,T2> FFt<T1,T2> for FF<T1,T1> {
    |          -- type parameter 'T1' declared here
171 |         fn call<T1,T2>(&self,t_1 : Self::t1,t_2 : Self::t2) {
172 |             t_1.a = 1;
    |                 ^

error[E0609]: no field `b` on type `T2`
   --> p2p/./src/lib.rs:173:17
    |
170 |     impl<T1,T2> FFt<T1,T2> for FF<T1,T1> {
    |             -- type parameter 'T2' declared here
...
173 |             t_2.b = 1;
    |                 ^

错误原因拆解 #

1. 泛型参数遮蔽：impl<T1,T2>里声明的泛型参数，被call方法内的<T1,T2>完全覆盖。方法内的新泛型没有任何约束，编译器根本不知道它们拥有a或b字段，自然报错。
2. Trait定义错误：Rust中关联类型的写法不是type t1 = T1，这属于无效语法。你的Trait已经携带了T1、T2泛型参数，完全不需要额外声明关联类型，属于画蛇添足。
3. 多余的方法泛型：call方法的<t1,t2>泛型参数完全没必要——你参数用的Self::t1、Self::t2本来就来自Trait的泛型，加了反而遮蔽外部泛型，导致类型约束失效。
4. 传值修改无效：就算编译通过，你现在是按值传递AA对象，修改的只是副本，外部fff里的对象根本不会变化，这应该不是你想要的效果。

修复后的代码示例 #

方案一：直接针对AA类型实现 #

如果你的逻辑只需要支持AA类型，可直接简化实现：

struct FF<T1, T2>(T1, T2);

// 移除无效关联类型，直接用Trait泛型参数
trait FFt<T1, T2> {
    // 改用可变引用传递，才能修改原对象
    fn call(&self, t_1: &mut T1, t_2: &mut T2);
}

// 直接指定泛型为AA类型
impl FFt<AA, AA> for FF<AA, AA> {
    fn call(&self, t_1: &mut AA, t_2: &mut AA) {
        t_1.a = 1;
        t_2.b = 1;
    }
}

struct AA {
    a: i32,
    b: i32,
}

fn main() {
    let mut fff: FF<AA, AA> = FF(AA { a: 0, b: 0 }, AA { a: 0, b: 0 });
    // 传递可变引用修改原对象
    fff.call(&mut fff.0, &mut fff.1);
    println!("fff.0.a = {}, fff.1.b = {}", fff.0.a, fff.1.b);
}

方案二：泛型通用实现 #

如果需要支持更多类型，可通过额外Trait约束泛型：

struct FF<T1, T2>(T1, T2);

// 定义Trait约束类型具备修改a、b字段的能力
trait HasA {
    fn set_a(&mut self, val: i32);
}

trait HasB {
    fn set_b(&mut self, val: i32);
}

// 给AA实现这两个Trait
impl HasA for AA {
    fn set_a(&mut self, val: i32) {
        self.a = val;
    }
}

impl HasB for AA {
    fn set_b(&mut self, val: i32) {
        self.b = val;
    }
}

// 在Trait上添加泛型约束
trait FFt<T1, T2> where T1: HasA, T2: HasB {
    fn call(&self, t_1: &mut T1, t_2: &mut T2);
}

// 实现通用的FFt逻辑
impl<T1: HasA, T2: HasB> FFt<T1, T2> for FF<T1, T1> {
    fn call(&self, t_1: &mut T1, t_2: &mut T2) {
        t_1.set_a(1);
        t_2.set_b(1);
    }
}

struct AA {
    a: i32,
    b: i32,
}

fn main() {
    let mut fff: FF<AA, AA> = FF(AA { a: 0, b: 0 }, AA { a: 0, b: 0 });
    fff.call(&mut fff.0, &mut fff.1);
    println!("fff.0.a = {}, fff.1.b = {}", fff.0.a, fff.1.b);
}

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