8.3 完全限定语法

在 Rust 中，当多个 trait 为同一类型实现了同名方法，或一个类型自身的方法与 trait 方法名称冲突时，编译器可能无法确定你希望调用哪一个。此时，完全限定语法（Fully Qualified Syntax）提供了一种明确指定调用目标的方式，确保代码无歧义。

方法调用的歧义场景

考虑以下例子：

trait Fly {
    fn get_id(&self) -> u32;
}

trait Swim {
    fn get_id(&self) -> String;
}

struct Duck;

impl Fly for Duck {
    fn get_id(&self) -> u32 { 100 }
}

impl Swim for Duck {
    fn get_id(&self) -> String { "duck".to_string() }
}

现在，Duck 同时实现了 Fly 和 Swim，且两个 trait 都定义了 get_id 方法，但返回类型不同。如果直接写：

let d = Duck;
d.get_id(); // ❌ 编译错误：ambiguous method call

编译器无法判断应调用哪个 get_id。

使用完全限定语法

完全限定语法的格式为：

<Type as Trait>::method(receiver, args...)

通过显式指定类型和 trait，可以消除歧义：

let d = Duck;
let fly_id = <Duck as Fly>::get_id(&d);    // 调用 Fly::get_id，返回 u32
let swim_id = <Duck as Swim>::get_id(&d);  // 调用 Swim::get_id，返回 String

注意：这里必须传递 &d 作为第一个参数，因为方法签名是 &self。

自身方法与 trait 方法冲突

即使没有多个 trait，当类型自身实现了与 trait 同名的方法时，也可能需要完全限定语法：

trait Speak {
    fn talk(&self);
}

struct Person;

impl Person {
    fn talk(&self) {
        println!("Person talking");
    }
}

impl Speak for Person {
    fn talk(&self) {
        println!("Speaking trait implementation");
    }
}

默认情况下，person.talk() 会调用 类型自身的方法（优先级更高）。若要调用 trait 实现，需使用完全限定语法：

let p = Person;
p.talk();                        // 输出: Person talking
<Person as Speak>::talk(&p);     // 输出: Speaking trait implementation

或者先将值转为 trait 对象：

let speak_p: &dyn Speak = &p;
speak_p.talk(); // 调用 trait 方法

在泛型上下文中的必要性

在泛型函数中，有时必须使用完全限定语法来帮助编译器推断：

fn call_get_id<T: Fly + Swim>(obj: &T) {
    let id1 = <T as Fly>::get_id(obj);
    let id2 = <T as Swim>::get_id(obj);
    // ...
}

如果不加限定，obj.get_id() 仍然模糊。

小结

完全限定语法虽然冗长，但在处理方法名冲突、实现精确控制或编写通用库代码时不可或缺。它体现了 Rust 的设计哲学：在需要明确性的场合，不依赖隐式规则，而是要求开发者清晰表达意图。掌握这一语法，有助于你在复杂的 trait 组合场景中写出可靠且可维护的代码。