奇怪的是,重复出现的通用特征模式:溢出评估需求

内容来源于 Stack Overflow,并遵循CC BY-SA 3.0许可协议进行翻译与使用

  • 回答 (2)
  • 关注 (0)
  • 查看 (73)

我试图用一堆字段实现一个泛型结构,每个字段类型都应该知道整个结构的确切类型。这是一种战略模式。

pub struct Example<S: Strategy<Example<S, D>>, D> {
    pub s: S,
    pub a: S::Associated,
    pub data: D,
}
pub trait Strategy<T> {
    type Associated;
    fn run(&self, &T);
}
pub trait HasData {
    type Data;
    fn data(&self) -> &Self::Data;
}

impl<S: Strategy<Self>, D> Example<S, D> {
//               ^^^^
// the complex code in this impl is the actual meat of the library:
    pub fn do_it(&self) {
        self.s.run(self); // using the Strategy trait
    }
}
impl<S: Strategy<Self>, D> HasData for Example<S, D> {
    type Data = D;
    fn data(&self) -> &D {
        &self.data
    }
}

然后,我计划从上面的“库”中实例化泛型:

pub struct ExampleStrat;
pub struct ExampleData;

impl<E: HasData<Data = ExampleData>> Strategy<E> for ExampleStrat {
    type Associated = ();
    fn run(&self, e: &E) {
        let _ = e.data();
        // uses ExampleData here
    }
}
let example = Example {
    s: ExampleStrat,
    a: (),
    data: ExampleData,
};
example.do_it();

在我的实际代码中,我有很多不同的“策略”,还有多个数据字段,所以Exampletype有一个令人印象深刻的泛型列表,我很高兴库用户不需要对它们进行明确的说明(或者至少不经常这样),而只需使用HasData属性(与其关联类型,而不是泛型类型参数)。

struct当结构只用于约束类型时,在我的例子中,我实际上需要他们能够使用Associated类型为a场。

现在编译器在抱怨

error[E0275]: overflow evaluating the requirement `main::ExampleStrat: Strategy<Example<main::ExampleStrat, main::ExampleData>>`
  --> src/main.rs:42:9
   |
42 |         a: (),
   |         ^^^^^
   |
   = note: required because of the requirements on the impl of `HasData` for `Example<main::ExampleStrat, main::ExampleData>`
   = note: required because of the requirements on the impl of `Strategy<Example<main::ExampleStrat, main::ExampleData>>` for `main::ExampleStrat`
提问于
用户回答回答于

如果下列impl是为Strategy,那么它可能会在错误的事情上被参数化。(我将忽略这个答案的关联类型,因为这个例子没有使用它。)

impl<E: HasData<Data = ExampleData>> Strategy<E> for ExampleStrat {
    fn run(&self, e: &E) {
        let _ = e.data();
        // uses ExampleData here
    }
}

你可以用参数化Strategy过关D-打破impl依赖周期-并且只参数化run方法过载E

pub trait Strategy<D> {
    fn run(&self, &impl HasData<Data = D>);
}

impl Strategy<ExampleData> for ExampleStrat {
    fn run(&self, e: &impl HasData<Data = ExampleData>) {
        let _ = e.data();
        // uses ExampleData here
    }
}

fn run<E: HasData<Data = ExampleData>>(&self, e: &E)是另一种定义run为此目的也是如此。

这种方法的一个潜在缺点是run不能通过Strategy对象,因为对于任何实现HasData。但HasData在这方面,特质似乎没有多大作用。impl:它唯一能做的就是返回一个内部引用,一旦你拥有了它,就没有必要再使用它了。也许吧run你就可以&D参考?

pub trait Strategy<D> {
    fn run(&self, &D);
}

impl Strategy<ExampleData> for ExampleStrat {
    fn run(&self, _: &ExampleData) {
        // uses ExampleData here
    }
}

当然,现在你必须调用self.s.run(self.data())do_it,但这并不会使在灵活性方面比原来的版本更灵活,在原始版本中,如果它有效,只能调用Strategy<E>::run带有类型的论证&E

用户回答回答于

首先,如果避免在结构和特征的定义上加上特性限制,一切都会变得更加清晰。当事情变得复杂时,约束至少从同一个方向得到解决。

pub struct Example<S, D, A> {
    pub s: S,
    pub a: A,
    pub data: D,
}

pub trait Strategy<T> {
    type Associated;
    fn run(&self, &T);
}

pub trait HasData {
    type Data;
    fn data(&self) -> &Self::Data;
}

impl<S, D, A> Example<S, D, A>
where
    S: Strategy<Self, Associated = A>,
{
    pub fn do_it(&self) {
        self.s.run(self);
    }
}

impl<S, D, A> HasData for Example<S, D, A>
where
    S: Strategy<Self, Associated = A>,
{
    type Data = D;
    fn data(&self) -> &D {
        &self.data
    }
}

你的实现StrategyExampleStrat看起来是这样的:

impl<E: HasData<Data = ExampleData>> Strategy<E> for ExampleStrat {
    type Associated = ();
     // ...
}

这意味着正在为所有可能的限定类型定义它。E。类型检查器现在只能查看特征边界,它同样是泛型的,并且只能用其他特征来表示,这些特征彼此作为边界使用,所以类型检查器进入了一个循环。在循环中设置一个块,给它一个具体的类型,你知道。

pub struct ExampleStrat;
pub struct ExampleData;

impl Strategy<Example<ExampleStrat, ExampleData, ()>> for ExampleStrat {
    type Associated = ();
    fn run(&self, e: &Example<ExampleStrat, ExampleData, ()>) {
        let _ = e.data();
        // uses ExampleData here
    }
}

fn main() {
    let example = Example {
        s: ExampleStrat,
        a: (),
        data: ExampleData,
    };
    example.do_it();
}

扫码关注云+社区

领取腾讯云代金券

年度创作总结 领取年终奖励