泛型在特定类型中的重写实现

Question

我知道 Rust 不是一种“继承/子类型化”语言，但我想知道是否有可能在特定类型的泛型中覆盖实现：

trait Trait {}

enum Enum {}
impl Trait for Enum {}

struct Struct<T: Trait> {}
impl<T> Struct<T> where T: Trait {
    fn function(&self) {
        panic!("Not Implemented!")
    }
}

impl Struct<Enum> {
    fn function(&self) {
        println!("This works")
    }
}

fn main(){}

这会引发编译器错误

error[E0592]: duplicate definitions with name `function`
  --> foo.rs:10:5
   |
10 |     fn function(&self) {
   |     ^^^^^^^^^^^^^^^^^^ duplicate definitions for `function`
...
16 |     fn function(&self) {
   |     ------------------ other definition for `function`

有什么办法解决这个问题吗？

Answer 1

简答不，（目前）在 Rust 中没有办法有专门的实现。如果有的话，恕我直言，主要用例将是优化，即以更智能的方式做本质上相同的事情，具体针对所讨论的类型。

稍微长一点的答案：您可以滥用实现的优先级来达到那种效果。

use std::marker::PhantomData;

enum Enum {}

trait NotImplemented {
    fn function(&self);
}

impl<T> NotImplemented for Struct<T> {
    fn function(&self) {
        panic!("Not Implemented!")
    }
}

struct Struct<T> {
    marker: PhantomData<T>
}

impl Struct<Enum> {
    fn function(&self) {
        println!("This works")
    }
}

fn main(){
    let working = Struct::<Enum> { marker: PhantomData };
    let other = Struct::<()> { marker: PhantomData };

    working.function(); // Prints "This works"
    other.function(); // Prints "Not implemented"
}

我对用例知之甚少，无法告诉您这是否是个坏主意。至少它可能会让其他维护者感到惊讶，所以要小心。