rust - 在迭代可变成员时访问不可变方法

Question

在学习 Rust 中的迭代器时，我创建了以下结构来隐藏二维集合的实现:

use std::slice::{Items, MutItems};
use std::vec::{Vec};

pub struct Table<T> {
    pub width: uint,
    pub height: uint,
    data: Vec<T>
}

impl<T: Clone> Table<T> {
    pub fn from_elem(width: uint, height: uint, value: T) -> Table<T> {
        Table {
            width: width,
            height: height,
            data: Vec::from_elem(width * height, value)
        }
    }
}

impl<T> Table<T> {
    pub fn get_row_column(&self, index: uint) -> (uint, uint) {
        (index / self.width, index % self.width)
    }

    pub fn iter<'a>(&'a self) -> Items<'a, T> {
        self.data.iter()
    }

    pub fn iter_mut<'a>(&'a mut self) -> MutItems<'a, T> {
        self.data.iter_mut()
    }
}

iter 和 iter_mut 方法的目标是该结构的用户无需担心数据是否存储在行优先或列主要格式；迭代器将简单地以最有效的顺序提供元素。

但是，在使用这种数据结构时，我经常需要知道特定的行和列以便获取一些外部数据:

fn get_input(row: uint, column: uint) -> uint {
    row * 10 + column / 2
}

fn main() {
    let mut table = Table::from_elem(640, 480, 0u);

    for (index, value) in table.iter_mut().enumerate() {
        let (row, column) = table.get_row_column(index);
        *value = get_input(row, column);
    }
}

但是当我尝试调用 get_row_column 方法时，我收到以下编译器错误:

main.rs:56:33: 56:38 error: cannot borrow `table` as immutable because it is also borrowed as mutable
main.rs:56             let (row, column) = table.get_row_column(index);
                                           ^~~~~
main.rs:55:31: 55:36 note: previous borrow of `table` occurs here; the mutable borrow prevents subsequent moves, borrows, or modification of `table` until the borrow ends
main.rs:55         for (index, value) in table.iter_mut().enumerate() {
                                         ^~~~~
main.rs:59:6: 59:6 note: previous borrow ends here
main.rs:55         for (index, value) in table.iter_mut().enumerate() {
main.rs:56             let (row, column) = table.get_row_column(index);
main.rs:57             *value = get_input(row, column);
main.rs:58         }
main.rs:59     }
               ^

完成我在这里尝试做的事情的正确方法是什么？我可以添加一个 set 方法，它获取行号和列号并显式循环遍历行和列索引，但随后用户不得不担心行优先顺序与列优先顺序:

impl<T> Table<T> {        
    fn get_index(&self, row: uint, column: uint) -> uint {
        row * self.width + column
    }

    pub fn set(&mut self, row: uint, column: uint, value: T) {
        let index = self.get_index(row, column);
        self.data[index] = value;
    }
}

fn main() {
    let mut table = Table::from_elem(640, 480, 0u);

    for row in range(0, table.height) {
        for column in range(0, table.width) {
            table.set(row, column, get_input(row, column));
        }
    }
}

是否有一个约定或最佳实践来改变结构的内部成员，同时仍然允许访问不可变成员和方法？或者这是否完全违反了安全保证？

Answer 1

Matthieu M. 有一个正确的想法:使用迭代器返回 row 和 column，而不是直接暴露 index。不幸的是，Rust 中的闭包目前似乎是堆栈分配的，不能扩展到创建它们的堆栈帧之外，因此他提出的解决方案无法编译。

虽然使用迭代器适配器非常方便和简洁，但我们仍然可以通过创建新的迭代器对象来完成它。

关键是创建一个迭代器来跟踪我们需要的上下文，在本例中是表的维度:

pub struct TableItems<'a, T: 'a> {
    iter: Items<'a, T>,
    width: uint,
    height: uint
}

impl<'a, T> Iterator<&'a T> for TableItems<'a, T> {
    #[inline]
    fn next(&mut self) -> Option<&'a T> {
        self.iter.next()
    }
}

此结构包含 slice 模块提供的 Items 迭代器，以及来自的 width 和 height table 。实现 Iterator 特性就像将对 next 的调用传递给内部迭代器一样简单。

TableItems 结构只返回不可变引用，但我们可以为可变引用创建一个类似的引用:

pub struct MutTableItems<'a, T: 'a> {
    iter: MutItems<'a, T>,
    width: uint,
    height: uint
}

impl<'a, T> Iterator<&'a mut T> for MutTableItems<'a, T> {
    #[inline]
    fn next(&mut self) -> Option<&'a mut T> {
        self.iter.next()
    }
}

然后我们只需要添加一种方法将维度从 Table 对象传递到迭代器:

impl<T> Table<T> {
    pub fn iter<'a>(&'a self) -> TableItems<'a, T> {
        TableItems {
            iter: self.data.iter(),
            width: self.width,
            height: self.height
        }
    }

    pub fn iter_mut<'a>(&'a mut self) -> MutTableItems<'a, T> {
        MutTableItems {
            iter: self.data.iter_mut(),
            width: self.width,
            height: self.height
        }
    }
}

现在，这些迭代器本身并没有给我们带来任何好处；它们返回 Table 的值，但我们仍然没有 row 和 column。为此，我们可以添加我们自己的迭代器适配器，它通过为当前行和列递增单独的计数来模仿 iter 模块中的 Enumerate 特性:

impl<'a, A, T: Iterator<A>> Iterator<((uint, uint), A)> for TableEnumerate<T> {
    fn next(&mut self) -> Option<((uint, uint), A)> {
        match self.iter.next() {
            Some(value) => {
                let ret = Some(((self.row_count, self.column_count), value));

                self.column_count += 1;
                if self.column_count == self.width {
                    self.row_count += 1;
                    self.column_count = 0;
                }
                ret
            },
            None => None
        }
    }

    #[inline]
    fn size_hint(&self) -> (uint, Option<uint>) {
        self.iter.size_hint()
    }
}

此适配器是通用的，因此它可用于 TableItems 或 MutTableItems(或我们将来选择提出的任何其他内容)。

最后一步是创建返回 TableEnumerate 实例的方法:

impl<'a, T> TableItems<'a, T> {
    pub fn enumerate_2d(self) -> TableEnumerate<TableItems<'a, T>> {
        let width = self.width;
        let height = self.height;

        TableEnumerate {
            iter: self,
            width: width,
            height: height,
            row_count: 0,
            column_count: 0
        }
    }
}

impl<'a, T> MutTableItems<'a, T> {
    pub fn enumerate_2d(self) -> TableEnumerate<MutTableItems<'a, T>> {
        let width = self.width;
        let height = self.height;

        TableEnumerate {
            iter: self,
            width: width,
            height: height,
            row_count: 0,
            column_count: 0
        }
    }
}

我很想将这些命名为 enumerate，但编译器似乎在此之前找到了 enumerate 的 Iterator 实现。

有了这个完整的解决方案，可以像这样访问表格:

fn get_input(row: uint, column: uint) -> uint {
    row * 10 + column / 2
}

fn main() {
    let mut table = Table::from_elem(640, 480, 0u);

    for ((row, column), value) in table.iter_mut().enumerate_2d() {
        *value = get_input(row, column);
    }
}