Rust中的相互递归特性与默认实现

发布于03月22日

我希望有几个特性与一些默认实现(硬要求)，相互调用.当然，一个简单的方法是行不通的，因为特征A有特征B作为父，而特征A有特征B作为父. turtle 一路下来.我该怎么办？(我不能将这些特性组合在一起，它们应该在不同的文件中.

不工作的代码，证明了这个问题，将是

use std::fmt::Display;

trait A: B + Display {
    fn a(&self, count: i32) -> String {
        if count == 0 {
            String::new()
        } else {
            format!("[{}]a{}", self, self.b(count - 1))
        }
    }
}
impl A for String {}

trait B: A + Display {
    fn b(&self, count: i32) -> String {
        if count == 0 {
            String::new()
        } else {
            format!("[{}]b{}", self, self.a(count - 1))
        }
    }
}
impl B for String {}

fn main() {
    println!("{}", "Hello".to_string().a(3));
}

推荐答案

根据实际的最终目标，那么通过使用辅助特性和blanket implementation来做你正在做的事情会更容易.

简而言之，与其这样做:

trait Foo {
    fn foo(&self) {
        println!("default foo");
    }
}

impl Foo for String {}

然后你引入一个trait HasFoo并使用它触发一个blanket implementation的Foo.看起来像这样:

trait Foo {
    fn foo(&self);
}

trait HasFoo {}

impl<T> Foo for T
where
    T: HasFoo,
{
    fn foo(&self) {
        println!("default foo");
    }
}

impl HasFoo for String {}

我们可以对您的示例执行相同的操作，通过引入trait HasAB来触发A和B的blanket implementation:

(Rust Playground)

trait HasAB {}

trait A {
    fn a(&self, count: i32) -> String;
}

trait B {
    fn b(&self, count: i32) -> String;
}

impl<T> A for T
where
    T: HasAB + Display,
{
    fn a(&self, count: i32) -> String {
        if count == 0 {
            String::new()
        } else {
            format!("[{}]a{}", self, self.b(count - 1))
        }
    }
}

impl<T> B for T
where
    T: HasAB + Display,
{
    fn b(&self, count: i32) -> String {
        if count == 0 {
            String::new()
        } else {
            format!("[{}]b{}", self, self.a(count - 1))
        }
    }
}

现在你只需要执行以下操作，然后你的示例编译:

impl HasAB for String {}

此外，由于我们取消了A: B和B: A的界限.然后，你现在可以为不实现B的类型使用impl A，反之亦然.你以前做不到.

您仍然可以手动实现每个特征.不强制为所有类型实现所有它们.

否则，当你在处理违约问题时.然后，将代码移到不同的函数中是很常见的.就像这样:

impl A for Foo {
    fn a(&self, count: i32) -> String {
        default_a_where_b(self, count)
    }
}

fn default_a_where_b<T>(t: &T, count: i32) -> String
where
    T: B + Display,
{
    if count == 0 {
        String::new()
    } else {
        format!("[{}]a{}", t, t.b(count - 1))
    }
}

如果您想摆脱样板，那么您可以引入一个宏:

macro_rules! impl_A_where_B {
    ($t:ty) => {
        impl A for $t {
            fn a(&self, count: i32) -> String {
                default_a_where_b(self, count)
            }
        }
    };
}

and vice versa for 100.

现在你只需做: