自定义类型的IntoIterator实现为何与core crate中的实现发生冲突？

我可以为自定义类型FakeReader实现引用版的IntoIterator，但当将IntoIterator作为自定义traitBmpReader的绑定条件时，却无法为FakeReader实现BmpReader。编译器错误提示FakeReader不是Iterator，但我明明只实现了引用类型的IntoIterator，却被要求类型自身必须满足IntoIterator约束。

示例代码 #

use core::iter::Iterator;

/// 自定义的目标trait
pub trait BmpReader : IntoIterator {
    const INTERNAL_BUFFER_SIZE: usize;
}

// 取消注释下方代码会触发错误
//impl BmpReader for FakeReader {
//     const INTERNAL_BUFFER_SIZE: usize = 20;
//}

impl<'a> IntoIterator for &'a FakeReader {
    type Item = &'a [u8];
    type IntoIter = FakeReaderIterator<'a>;

    fn into_iter(self) -> Self::IntoIter {
        Self::IntoIter{
            reader: &self,
            index: 0,
        }
    }
}

struct FakeReader {
    buffer: [u8; 20],
}

pub struct FakeReaderIterator<'a> {
    reader: &'a FakeReader,
    index: usize
}

impl<'a> Iterator for FakeReaderIterator<'a> {
    type Item = &'a [u8];

    fn next(&mut self) -> Option<Self::Item> {
        if self.index == self.reader.buffer.len() {
            return None;
        }
        let result = &self.reader.buffer[self.index..self.index+1];
        self.index += 1;
        Some(result)
    }
}

fn main() {
    let mut reader = FakeReader {
        buffer: [0u8; 20]
    };
    let _= reader.buffer.iter_mut().enumerate().map(|(i,v)| *v = i as u8).count();
    for i in &reader {
        println!("{:?}", i)
    }
}

编译错误信息 #

error[E0277]: `FakeReader` is not an iterator
 --> src/main.rs:9:6
  |
9 | impl BmpReader for FakeReader {
  |      ^^^^^^^^^ `FakeReader` is not an iterator
  |
  = help: the trait `Iterator` is not implemented for `FakeReader`
  = help: the trait `IntoIterator` is implemented for `&'a FakeReader`
  = note: required because of the requirements on the impl of `IntoIterator` for `FakeReader`
note: required by a bound in `BmpReader`
 --> src/main.rs:4:23
  |
4 | pub trait BmpReader : IntoIterator {
  |                       ^^^^^^^^^^^^ required by this bound in `BmpReader`

问题根源 #

trait BmpReader : IntoIterator的语法要求类型本身（FakeReader）必须实现IntoIterator，而非它的引用类型&FakeReader。Rust的trait绑定默认作用于类型自身，你仅为&'a FakeReader实现了IntoIterator，并未满足类型自身的约束，因此编译器报错。

两种可行解决思路 #

思路1：为FakeReader本身实现IntoIterator

如果业务场景允许消费FakeReader（即转移所有权），可以直接为类型本身添加IntoIterator实现：

impl IntoIterator for FakeReader {
    type Item = u8;
    type IntoIter = std::array::IntoIter<u8, 20>;

    fn into_iter(self) -> Self::IntoIter {
        self.buffer.into_iter()
    }
}

添加该实现后，FakeReader自身满足IntoIterator约束，即可正常实现BmpReader。

思路2：调整trait BmpReader的绑定逻辑

如果不想让FakeReader本身实现IntoIterator，而是希望通过引用版本满足迭代需求，可以修改trait定义，灵活指定迭代方式：

pub trait BmpReader {
    const INTERNAL_BUFFER_SIZE: usize;
    // 定义关联类型描述迭代器
    type Iter<'a>: Iterator<Item = &'a [u8]> where Self: 'a;
    // 提供获取迭代器的方法
    fn iter(&self) -> Self::Iter<'_>;
}

// 为FakeReader实现调整后的BmpReader
impl BmpReader for FakeReader {
    const INTERNAL_BUFFER_SIZE: usize = 20;
    type Iter<'a> = FakeReaderIterator<'a>;
    
    fn iter(&self) -> Self::Iter<'_> {
        FakeReaderIterator { reader: self, index: 0 }
    }
}

这种方式无需依赖IntoIterator的类型绑定，直接通过自定义方法提供迭代能力，更贴合引用迭代的场景。

内容的提问来源于stack exchange，提问作者Javier Cardona