Доступ к неизменяемым методам во время итерации по изменяемому члену

У Матье М. правильная идея: использовать итератор для возврата 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()
    }
}

Эта структура содержит итератор Items, предоставленный модулем slice, а также width и height из таблицы. Реализовать трейт 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. Для этого мы можем добавить наш собственный адаптер итератора, который имитирует черту Enumerate из модуля iter, увеличивая отдельные счетчики для текущей строки и столбца:

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, но похоже, что компилятор находит Iterator реализацию enumerate раньше этой.

С помощью этого комплексного решения к таблице можно получить доступ следующим образом:

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);
    }
}

Это не проблема изменчиво-неизменяемая, это просто двойное заимствование. Если бы внутренний вызов метода был &mut self методом, у вас были бы те же проблемы. Вы не потеряли доступ к неизменяемым методам, вы потеряли доступ ко всем методам, пока value находится в области видимости, поскольку value является заимствованным в таблице.

Хотя в данном конкретном случае этого не происходит, наличие нескольких псевдонимов для повторяемой части может привести к недействительности итератора.

В этом случае используйте map для выполнения вычислений:

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

    for (value, row, column) in table.iter_mut().enumerate().map(|(i,v)| (v, i / width, i % width) ) {
        *value = get_input(row, column);
    }
}

манеж

Помогло бы и выделение get_row_column отдельной функции.

Я бы сказал, что проблема здесь в дырявой абстракции: index никогда не должен открываться пользователю с самого начала.

Следовательно, вам нужно будет изменить интерфейс, чтобы напрямую предоставлять (row, column) вместо index при итерации, и тогда использование будет простым.

Что-то вроде:

use std::iter::{Enumerate, Map}

impl<T> Table<T> {
    // Additions
    pub fn iter_enum<'a>(&'a self) -> Map<'a, (uint, &'a T), ((uint, uint), &'a T), Enumerate<Items<'a, T>>> {
        self.iter().enumerate().map(|(i, v)| ((i / self.width, i % self.width), v)
    }

    pub fn iter_mut_enum<'a>(&'a mut self) -> Map<'a, (uint, &'a mut T), ((uint, uint), &'a mut T), Enumerate<MutItems<'a, T>>> {
        self.iter_mut().enumerate().map(|(i, v)| ((i / self.width, i % self.width), v)
    }
}

Примечание. Я хочу, чтобы здесь было много псевдонимов шаблонов C ++.