rust - 我可以在嵌套类型上专门化特征吗？

Question

我有一个队列 Strategy Monotonic 的实现特征和 LastTick在我要插入的类型上进行参数化:

struct Monotonic<T> {
    items: Vec<T>,
}
struct LastTick<T> {
    items: Vec<T>,
}

struct SetDelta;

trait Strategy<T> {
    type T;
    fn enqueue(&mut self, v: T);
    fn has_pending(&self) -> bool;
}

impl<T> Strategy<T> for Monotonic<T> {
    type T = Self;
    fn enqueue(&mut self, v: T) {
        self.items.push(v);
    }
    fn has_pending(&self) -> bool {
        !self.items.is_empty()
    }
}

impl<T> Strategy<T> for LastTick<T> {
    type T = Self;
    fn enqueue(&mut self, v: T) {
        self.items.push(v);
    }
    fn has_pending(&self) -> bool {
        !self.items.is_empty()
    }
}

impl<T> Strategy<T> for LastTick<T> {
    type T = Self;
    fn enqueue(&mut self, v: T) {
        self.items.push(v);
    }
    fn has_pending(&self) -> bool {
        !self.items.is_empty()
    }
}

impl<T> LastTick<T> {
    fn new() -> Self {
        LastTick { items: Vec::new() }
    }
}
impl<T> Monotonic<T> {
    fn new() -> Self {
        Monotonic { items: Vec::new() }
    }
}

#[test]
fn monotonic_scalar_queue() {
    let mut a = Monotonic::<f64>::new();
    a.enqueue(123.4);
    assert!(a.has_pending());
}

#[test]
fn monotonic_list_queue() {
    let mut a = Monotonic::<[f64; 3]>::new();
    a.enqueue([123.4, 345.8, 324.1]);
    assert!(a.has_pending());
}

#[test]
fn monotonic_tuple_queue() {
    let mut a = Monotonic::<(f64, String, u32)>::new();
    a.enqueue((123.4, "hello".into(), 324));
    assert!(a.has_pending());
}

以上工作正常。我想为 HashSet 保留相同的界面行为略有不同。

#[test]
fn monotonic_set_queue() {
    let mut a = Monotonic::<HashSet<f64>>::new();
    // I want to insert a f64 and implement the logic of the hashset in
    // the implementation, but it expects a new HashSet
    a.enqueue(123.4);
    assert!(a.has_pending());
}

我试过了

impl<T> Strategy<T> for Monotonic<HashSet<f64>> {
    type T = Self;
    fn enqueue(&mut self, v: T) {
        self.items.push(v);
    }
    fn has_pending(&self) -> bool {
        !self.items.is_empty()
    }
}

还有

impl Strategy<f64> for Monotonic<f64> {
    type T = HashSet<f64>;
    fn enqueue(&mut self, v: f64) {
        self.items.push(v);
    }
    fn has_pending(&self) -> bool {
        !self.items.is_empty()
    }
}

有不同的结果，但没有运气。有没有办法轻松指定它？

Answer 1

您似乎想要 Monotonic<T> 的不同实现方式，其中集合不是 Vec - 你目前定义的方式是不可能的 Monotonic .相反，您可以创建另一种类型 MonotonicHashSet<T> ，并使用 HashSet作为支持集合。

相反，如果您想制作 Monotonic接受不同的集合类型，那么您可能还想在集合类型上泛化它。然而，这可能会很快变得复杂。在 Rust 中，我们通常与集合相关联的属性分为几个特征，定义在 iter module 中。 .它们被分开，这样每个集合类型都可以针对集合所具有的任何约束，精确而正确地定义它的行为。所以，对于你的 Monotonic和 LastTick类型，重要的是要考虑您可能有什么要求，以及这意味着您需要哪些特征才能与该类型一起使用集合。

最后一点:虽然Vec接受任何类型 T , 一个 HashSet需要来自 Eq 的完全平等特征和可散列性，通过 Hash特征。这些不同的要求值得考虑，因为与 C# 等不同，Rust 不为所有类型提供这些操作的默认实现——您必须提供它们或 #[derive()] them .