特征的泛型类型和泛型关联类型有什么区别？

Question

这个问题是在泛型关联类型在Rust中可用之前提出的，尽管它们是被提出和开发的。

我的理解是，特征泛型和关联类型在它们可以绑定到结构的类型数量上有所不同。

struct Struct;

trait Generic<G> {
    fn generic(&self, generic: G);
}

impl<G> Generic<G> for Struct {
    fn generic(&self, _: G) {}
}

fn main() {
    Struct.generic(1);
    Struct.generic("a");
}

关联类型仅绑定1个类型：

struct Struct;

trait Associated {
    type Associated;

    fn associated(&self, associated: Self::Associated);
}

impl Associated for Struct {
    type Associated = u32;

    fn associated(&self, _: Self::Associated) {}
}

fn main() {
    Struct.associated(1);
    // Struct.associated("a"); // `expected u32, found reference`
}

泛型关联类型是这两种类型的混合。它们绑定到一个类型，正好有一个关联的生成器，而生成器又可以关联任何数量的类型。那么前面示例中的generic和这个泛型关联类型有什么区别呢？

struct Struct;

trait GenericAssociated {
    type GenericAssociated;

    fn associated(&self, associated: Self::GenericAssociated);
}

impl<G> GenericAssociated for Struct {
    type GenericAssociated = G;

    fn associated(&self, _: Self::GenericAssociated) {}
}

Answer 1

我们再来看看你最后一个例子（被我缩短了）：

trait GenericAssociated {
    type GenericAssociated;
}

impl<G> GenericAssociated for Struct {
    type GenericAssociated = G;
}

这不具有泛型关联类型的特性！您只是在impl块上有一个泛型类型，您将该泛型类型分配给关联的类型。嗯，好吧，我知道混乱是从哪里来的了。

您的示例错误为“类型参数g不受impl特征、self类型或谓词的约束”。当《服贸总协定》实施时，这一点不会改变，因为，再一次，这与《服贸总协定》无关。

trait Associated {
    type Associated<T>; // <-- note the `<T>`! The type itself is 
                        //     generic over another type!

    // Here we can use our GAT with different concrete types 
    fn user_choosen<X>(&self, v: X) -> Self::Associated<X>;
    fn fixed(&self, b: bool) -> Self::Associated<bool>;
}

impl Associated for Struct {
    // When assigning a type, we can use that generic parameter `T`. So in fact,
    // we are only assigning a type constructor.
    type Associated<T> = Option<T>;

    fn user_choosen<X>(&self, v: X) -> Self::Associated<X> {
        Some(x)
    }
    fn fixed(&self, b: bool) -> Self::Associated<bool> {
        Some(b)
    }
}

fn main() {
    Struct.user_choosen(1);    // results in `Option<i32>`
    Struct.user_choosen("a");  // results in `Option<&str>`
    Struct.fixed(true);        // results in `Option<bool>`
    Struct.fixed(1);           // error
}

流式迭代器的GAT版本如下所示：

trait Iterator {
    type Item<'a>;
    fn next(&self) -> Option<Self::Item<'_>>;
}

在current Rust中，我们可以将lifetime参数放在trait上，而不是相关的类型：

trait Iterator<'a> {
    type Item;
    fn next(&'a self) -> Option<Self::Item>;
}

到目前为止还不错：所有迭代器都可以像以前一样实现这个特性。但如果我们要用呢？

fn count<I: Iterator<'???>>(it: I) -> usize {
    let mut count = 0;
    while let Some(_) = it.next() {
        count += 1;
    }
    count
}

null

fn count<I: Iterator>(it: I) { ... }

它会奏效的。因为“具体生存期的应用”只有在我们调用next时才会发生。

如果您对更多信息感兴趣，可以看看我的博客文章“在没有GATS的情况下解决Generalized Streaming Iterator Problem”，我尝试在traits上使用泛型类型来解决GATS的不足。而且（剧透）：通常都不起作用。