rust - IntoIterator返回的代理类型，它将在Rust的迭代过程中返回索引

Question

TL; DR:是否有某种方法可以同时为可变和不可变的变体提供实现？
我刚刚开始学习Rust，我想做的第一件事是对代理类使用IntoIterator，该类跟踪2D x和y索引，底层结构是线性Vec<f32>。
像这样的东西:

#[derive(Clone, Debug)]
pub struct Array {
    inner: Vec<f32>,
    width: usize,
}

pub struct ArrayItem<'a> {
    pub x: usize,
    pub y: usize,
    pub element: &'a f32 // value
}

pub struct TwoDimIter<T>
where 
    T: Iterator
{
    cur_x: usize,
    cur_y: usize,
    width: usize,
    inner_iter: T // Iterator to underlying Vec<f32>
}

impl<'a, T> Iterator for TwoDimIter<T>
where T: Iterator<Item = &'a f32>
{
    type Item = ArrayItem<'a>;
    fn next(&mut self) -> std::option::Option<<Self as std::iter::Iterator>::Item> {
        let op_value = self.inner_iter.next();
        if op_value.is_some() {
            self.cur_x += 1;
            self.cur_y += self.cur_x / self.width; // usually 0
            self.cur_x %= self.width; // usually the same as was before

            Some(ArrayItem{ x: self.cur_x, y: self.cur_y, element: op_value.unwrap() })
        } else {
            None
        }
    }
}

因此用法如下所示:

pub fn gauss_seidel(output: &mut Array, input: &Array, weight: f32) {
    for val in input {
        let (x, y, &value) = (val.x, val.y, val.element);
    }
}

我主要关注 Vec本身的实现，最终得到了大量代码，因为我必须复制为Mutable变体引入的每个结构(如果作为 &mut Array传递)。
我已经习惯了C++模板，并且想以某种方式合并可变和不可变变量的实现(例如，基于函数的返回类型-像SFINAE一样)，但是我失败了-我不知道该怎么做。
是否有某种方式可以同时为可变和不可变变体提供实现？
我有完整的代码:

#[derive(Clone, Debug)]
pub struct Array {
    inner: Vec<f32>,
    width: usize,
}

impl Array {
    pub fn new(width: usize, height: usize) -> Array {
        Array { inner: vec![0.; width * height], width }
    }

    pub fn get(&self, x: usize, y: usize) -> Option<&f32> {
        self.inner.get(y * self.width + x)
    }

    pub fn get_mut(&mut self, x: usize, y: usize) -> Option<&mut f32> {
        self.inner.get_mut(y * self.width + x)
    }
}

pub struct ArrayItem<'a> {
    pub x: usize,
    pub y: usize,
    pub element: &'a f32
}

pub struct MutArrayItem<'a> {
    pub x: usize,
    pub y: usize,
    pub element: &'a mut f32
}

pub struct TwoDimIter<T>
where 
    T: Iterator
{
    cur_x: usize,
    cur_y: usize,
    width: usize,
    inner_iter: T
}

impl<'a, T> Iterator for TwoDimIter<T>
where T: Iterator<Item = &'a f32>
{
    type Item = ArrayItem<'a>;
    fn next(&mut self) -> std::option::Option<<Self as std::iter::Iterator>::Item> {
        let op_value = self.inner_iter.next();
        if op_value.is_some() {
            self.cur_x += 1;
            self.cur_y += self.cur_x / self.width; // usually 0
            self.cur_x %= self.width; // usually the same as was before

            Some(ArrayItem{ x: self.cur_x, y: self.cur_y, element: op_value.unwrap() })
        } else {
            None
        }
    }
}

pub struct MutTwoDimIter<T>
where
    T: Iterator
{
    cur_x: usize,
    cur_y: usize,
    width: usize,
    inner_iter: T
}

impl<'a, T> Iterator for MutTwoDimIter<T>
where T: Iterator<Item = &'a mut f32>
{
    type Item = MutArrayItem<'a>;
    fn next(&mut self) -> std::option::Option<<Self as std::iter::Iterator>::Item> {
        let op_value = self.inner_iter.next();
        if op_value.is_some() {
            self.cur_x += 1;
            self.cur_y += self.cur_x / self.width; // usually 0
            self.cur_x %= self.width; // usually the same as was before

            Some(MutArrayItem{ x: self.cur_x, y: self.cur_y, element: op_value.unwrap() })
        } else {
            None
        }
    }
}

use core::slice::{self};

impl<'a> IntoIterator for &'a Array {
    type Item = ArrayItem<'a>;
    type IntoIter = TwoDimIter<slice::Iter<'a, f32>>;

    fn into_iter(self) -> <Self as std::iter::IntoIterator>::IntoIter { 
        TwoDimIter{ cur_x: 0, cur_y: 0, width: self.width, inner_iter: self.inner.iter() }
    }
}

impl<'a> IntoIterator for &'a mut Array {
    type Item = MutArrayItem<'a>;
    type IntoIter = MutTwoDimIter<slice::IterMut<'a, f32>>;

    fn into_iter(self) -> <Self as std::iter::IntoIterator>::IntoIter { 
        MutTwoDimIter{ cur_x: 0, cur_y: 0, width: self.width, inner_iter: self.inner.iter_mut() }
    }
}

Answer 1

你已经很近了；您太早就太具体了。 TwoDimIter实际上是一个通用的迭代器适配器。您可以使用它包装任何类型的迭代器，而不仅仅是std::slice::Iter。实际上，TwoDimIter非常类似于std::iter::Enumerate，只是它很时髦。因此，让我们从Enumerate中获取提示。

pub struct Enumerate2D<I> {
    index: usize,
    width: usize,
    inner: I,
}

impl<I> Iterator for Enumerate2D<I>
where I: Iterator
{
    // I'll use tuples here instead of a custom ArrayItem struct but that would
    // work fine too if you want
    type Item = ((usize, usize), I::Item);

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next().map(|item| {
            let (x, y) = (self.index % self.width, self.index / self.width);
            self.index += 1;
            ((x, y), item)
        })
    }
}

这是我们唯一需要编写的 Iterator实现，因为它适用于任何 Item。如果愿意，可以编写一个扩展特性，为所有 Iterator提供一个 .enumerate_2d(width)方法来包装它。但是现在，我们只为 IntoIterator和 &Array编写 &mut Array实现:

impl<'a> IntoIterator for &'a Array {
    type IntoIter = Enumerate2D<slice::Iter<'a, f32>>;
    type Item = <Self::IntoIter as Iterator>::Item;

    fn into_iter(self) -> <Self as std::iter::IntoIterator>::IntoIter { 
        Enumerate2D { index: 0, width: self.width, inner: self.inner.iter() }
    }
}

impl<'a> IntoIterator for &'a mut Array {
    type IntoIter = Enumerate2D<slice::IterMut<'a, f32>>;
    type Item = <Self::IntoIter as Iterator>::Item;

    fn into_iter(self) -> <Self as std::iter::IntoIterator>::IntoIter { 
        Enumerate2D { index: 0, width: self.width, inner: self.inner.iter_mut() }
    }
}

我们仍然需要同时编写两者，因为实际上没有任何方法可以同时抽象出不同的引用类型和不同的迭代器类型。您可以编写一个宏，但是它有点困难，对于两个实现来说，可能不值得。如果需要，也可以为 Array写一个:

impl IntoIterator for Array {
    type IntoIter = Enumerate2D<std::vec::IntoIter<f32>>;
    type Item = <Self::IntoIter as Iterator>::Item;

    fn into_iter(self) -> <Self as std::iter::IntoIterator>::IntoIter { 
        Enumerate2D { index: 0, width: self.width, inner: self.inner.into_iter() }
    }
}

您可以像使用 Enumerate一样使用它们:

for ((x, y), value) in input {
    // ...
}