Question

我正在尝试使用一堆字段实现通用结构，其中每个字段类型应该知道整个结构的确切类型。这是一种策略模式。

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
    }
}

我计划然后从上面的＃34;库中实例化泛型：

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();

在我的实际代码中，我有很多不同的＆＃34;策略＆＃34;以及多个数据字段，因此Example类型具有令人印象深刻的泛型列表，如果图书馆用户不需要明确它们（或者至少不是这样），我感到高兴而只能使用HasData特征（及其相关类型，而不是泛型类型参数）。

如果struct Example<S, D>中没有类型绑定，这实际上会（令人惊讶地）很好，比我最初预期的更好（在fighting with Self in the struct bounds之后）。但是，当结构仅应该与约束类型一起使用时，建议duplicate the impl trait bounds on the 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`

我该如何解决这个问题呢？我是在尝试做一些不可能做的事情，我做错了，还是应该有可能但我会成为{{3}的牺牲品}？我的完整设计是否有缺陷？

Answer 1

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

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
    }
}

Strategy的{{1}}实现如下：

ExampleStrat

这意味着您要为所有可能的限定类型impl<E: HasData<Data = ExampleData>> Strategy<E> for ExampleStrat { type Associated = (); // ... }定义它。类型检查器现在只能查看特征边界，这些特征边界再次是通用的，并且仅以其他特征表示，它们彼此使用作为边界，因此类型检查器进入循环。通过给出一个具体的类型，在一个循环中放一个块，你知道。

Answer 2

如果以下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的方法，它与此目的相同。 Here is a full example

这种方法的一个潜在缺点是无法通过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，但这并不会让你在原始版本上花费灵活性，如果它工作¹，你只能致电{ {1}}参数类型为Strategy<E>::run。

事实上，整个&E特征对我来说似乎没有必要：它总是由实现调用它的相同类型实现，所以除了传递HasData而不是{{1}的轻微便利之外}，它不会提升self方法中的抽象级别。所以在我看来delete HasData entirely实际上是一样的，让self.data知道如何用正确的引用来调用do_it;无论如何，它必须。（但是，我可能只是缺乏想象力。）

任何这些解决方案都应该处理向Example添加相关类型，但不知道如何使用它，很难肯定。

¹可以在未来的编译器版本中工作，并进行足够智能的类型检查。

奇怪的重复通用特征模式：溢出评估需求

2 个答案: