Блог*

Посмотрим, как реализован Iterator::next для Fuse:

    default fn next(&mut self) -> Option<<I as Iterator>::Item> {
        if self.done {
            None
        } else {
            let next = self.iter.next();
            self.done = next.is_none();
            next
        }
    }

Здесь нагло эксплуатируется тот факт, что поле done имеет булев тип. Если мы хотим, чтобы адаптер не содержал флаг для fused итератора, нам нужно сделать тип флага зависящим от типа итератора. Т. к. теперь мы не можем считать флаг булевым, нам нужно абстрагироваться от конкретного типа. Немного перепишем реализацию метода:

    default fn next(&mut self) -> Option<<I as Iterator>::Item> {
        if self.done {
            None
        } else {
            let next = self.iter.next();
            if next.is_none() {
                self.done = true;
            }
            next
        }
    }

Как видно, от флага требуется две операции: проверка на то, выставлен ли он, и его установка в положение "да, сэр, к сожалению, этот джентельмен вернул None". Также нам нужно каким-то образом получить начальное значение флага, когда мы создаём адаптер. Выразим это в трейте:

trait Flag: Default {
    fn is_set(&self) -> bool;
    fn set(&mut self);
}

Этот трейт тривиально реализуется для bool:

impl Flag for bool {
    fn is_set(&self) -> bool {
        *self
    }

    fn set(&mut self) {
        *self = true
    }
}

Теперь подумаем, что нам требуется для fused итератора. Наш метод next будет эквивалентен вызову next у нижележащего итератора, если флаг всё время ведёт себя так, как будто он не выставлен (рекомендую ещё раз посмотреть на код выше, чтобы убедиться в этом). Создадим соответствующий тип и реализуем для него Flag:

#[derive(Default)]
struct False;

impl Flag for False {
    fn is_set(&self) -> bool {
        false
    }

    fn set(&mut self) {}
}

Теперь нам нужно сопоставить каждому итератору соответствующий тип флага. Именно здесь нам понадобится специализация: по умолчанию для итератора флагом является булев тип, но для fused итераторов (т. е. реализующих FusedIterator) это будет False. Непосредственно функций на уровне типов в Rust нет, но их роль играют трейты с ассоциированными типами.

trait FlagType: Iterator {
    type Flag: Flag + Default;
}

impl<I: Iterator> FlagType for I {
    // ключевое слово default позволяет нам переопределять элементы трейтов
    // в более специфичных impl-ах...
    default type Flag = bool;
}

impl<I: FusedIterator> FlagType for I {
    // ...что мы и делаем
    type Flag = False;
}

Теперь напишем сам адаптер. Ничего сложного в нём нет, нужно только иметь в виду, что нам требуется тип, для которого определён флаг:

struct SlimFuse<I: FlagType> {
    iter: I,
    finished: I::Flag,
}

После всего описанного выше нетрудно написать реализацию Iterator:

impl<I: FlagType> Iterator for SlimFuse<I> {
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        if self.finished.is_set() {
            return None;
        }

        let ret = self.iter.next();
        if ret.is_none() {
            self.finished.set();
        }
        ret
    }
}

Осталось только приправить extension trait для того, чтобы адаптер было удобно создавать:

trait IteratorExt: Sized + FlagType {
    fn fuse_slim(self) -> SlimFuse<Self>;
}

impl<I: Sized + FlagType> IteratorExt for I {
    fn fuse_slim(self) -> SlimFuse<Self> {
        SlimFuse {
            iter: self,
            finished: <_>::default(),
        }
    }
}

doc.rust-lang.org

mod.rs.html -- source

Source to the Rust file `src/libcore/iter/adapters/mod.rs`.

374 viewsedited 22:44