我可以有条件地提供特征函数的默认实现吗?

Question

我有以下特征：

trait MyTrait {
    type A;
    type B;
    fn foo(a: Self::A) -> Self::B;
    fn bar(&self);
}

还有其他函数，如bar，必须始终由特征的用户实现。

我想给foo一个默认实现，但只有当类型A = B .

伪锈代码：

impl??? MyTrait where Self::A = Self::B ??? {
    fn foo(a: Self::A) -> Self::B {
        a
    }
}

这是可能的：

struct S1 {}
impl MyTrait for S1 {
    type A = u32;
    type B = f32;
    // `A` is different from `B`, so I have to implement `foo`
    fn foo(a: u32) -> f32 {
        a as f32
    }
    fn bar(&self) {
        println!("S1::bar");
    }
}
struct S2 {}
impl MyTrait for S2 {
    type A = u32;
    type B = u32;
    // `A` is the same as `B`, so I don't have to implement `foo`,
    // it uses the default impl
    fn bar(&self) {
        println!("S2::bar");
    }
}

这在 Rust 中可能吗？

Answer 1

您可以通过引入冗余类型参数在特征定义本身中提供默认实现：

trait MyTrait {
    type A;
    type B;
    fn foo<T>(a: Self::A) -> Self::B
    where
        Self: MyTrait<A = T, B = T>,
    {
        a
    }
}

对于单个类型，可以重写此默认实现。但是，专用版本将继承从特征上的foo()定义绑定的 trait，因此只有在以下A == B情况下才能实际调用该方法：

struct S1;
impl MyTrait for S1 {
    type A = u32;
    type B = f32;
    fn foo<T>(a: Self::A) -> Self::B {
        a as f32
    }
}
struct S2;
impl MyTrait for S2 {
    type A = u32;
    type B = u32;
}
fn main() {
    S1::foo(42);  // Fails with compiler error
    S2::foo(42);  // Works fine
}

Rust 也有一个不稳定的 impl 专用化特性，但我认为它不能用来实现你想要的。

Answer 2

这就

足够了吗？

trait MyTrait {
    type A;
    type B;
    fn foo(a: Self::A) -> Self::B;
}
trait MyTraitId {
    type AB;
}
impl<P> MyTrait for P
where
    P: MyTraitId
{
    type A = P::AB;
    type B = P::AB;
    fn foo(a: Self::A) -> Self::B {
        a
    }
}
struct S2;
impl MyTraitId for S2 {
    type AB = i32;
}

锈游乐场

如前所述，如果MyTrait MyTraitId无法提供实现的其他方法，则会遇到问题。

Answer 3

扩展user31601的答案并使用Sven Marnach评论中的评论，以下是使用"委托方法"模式的附加函数实现的特征：

trait MyTrait {
    type A;
    type B;
    fn foo(a: Self::A) -> Self::B;
    fn bar();
}
trait MyTraitId {
    type AB;
    fn bar_delegate();
}
impl<P> MyTrait for P
where
    P: MyTraitId,
{
    type A = P::AB;
    type B = P::AB;
    fn foo(a: Self::A) -> Self::B {
        a
    }
    fn bar() {
        <Self as MyTraitId>::bar_delegate();
    }
}
struct S2;
impl MyTraitId for S2 {
    type AB = i32;
    fn bar_delegate() {
        println!("bar called");
    }
}
fn main() {
    <S2 as MyTrait>::bar(); // prints "bar called"
}

操场