rust - 为什么允许在对迭代器的可变引用上调用take()？

Question

我试图在迭代器上使用take(n)对第一个n项执行某些操作，但随后对其余项执行不同的操作(一个for ... in ...循环)。
在声明中:

fn take(self, n: usize) -> Take<Self>

self作为第一个参数告诉我 take()必须用于拥有的值，而不是引用( &self)或可变引用( &mut self)。 by_ref()的文档说它返回一个可变的引用，并且

This is useful to allow applying iterator adaptors while stillretaining ownership of the original iterator.

它包括一个使用 by_ref().take(n)的示例，然后继续使用迭代器(就像我想要的那样)。
我的问题是，为什么我允许在可变引用上调用 take()(而不是要求拥有值)？换句话说，不应将 take()声明为类似以下内容的代码:

fn take(&mut self, n: usize) -> Take<Self>

使它可以与可变引用一起使用？
我一直在寻找什么声明会告诉我这是可能的？

Answer 1

Rust将T，&T和&mut T视为单独的类型。作为单独的类型，我们可以为每个类型实现不同的方法。例子:

struct Struct;

trait Printable {
    fn print(self);
}

impl Printable for Struct {
    fn print(self) {
        println!("I'm an owned Struct");
    }
}

impl Printable for &Struct {
    fn print(self) {
        println!("I'm a Struct reference");
    }
}

fn main() {
    let s = Struct;
    let s_ref = &Struct;
    s.print();
    s_ref.print();
}

如果我们对特征方法进行脱糖，则会得到:

fn print(self: Self) { /* implementation */ }

其中 Self等于实现类型，在 Struct的情况下为:

fn print(self: Struct) { /* implementation */ }

在 &Struct的情况下是:

fn print(self: &Struct) { /* implementation */ }

因此，实际上 self可以是拥有的类型，不可变的引用或可变的引用。您可以在对 take的可变引用上调用 Iterator的原因是 because of this generic blanket impl which implements the Iterator trait on all mutable references to Iterator s:

impl<'_, I> Iterator for &'_ mut I where I: Iterator + ?Sized { /* implementation */ }

让我们使用 vec.into_iter()作为一个具体示例。由于它返回实现 std::vec::IntoIter的 Iterator，因此我们知道 take的这种实现必须存在:

take(self: std::vec::IntoIter, n: usize) -> Take<std::vec::IntoIter> { /* implementation */ }

但是，我们也知道 take的 &mut std::vec::IntoIter实现必须存在，因为它将由上述通用毯子impl自动生成，并且该实现的签名如下所示:

take(self: &mut std::vec::IntoIter, n: usize) -> Take<&mut std::vec::IntoIter> { /* implementation */ }

这就是为什么您可以在实现了 take的任何类型的任何可变引用上调用 Iterator的原因。