Previewable Iterator http://play.integer32.com/?gist=1af3d4465e6b9d13e024f2ce1241247d&version=stable

main.rs

use std::collections::VecDeque;

pub struct Preview<'a, T, I>
where
    I: Iterator<Item = T> + 'static,
    T: 'static,
{
    iter: &'a mut PreviewIterator<T, I>,
    buffer: Vec<T>,
}

pub struct PreviewIterator<T, I>
where
    I: Iterator<Item = T> + 'static,
{
    iter: I,
    buffer: VecDeque<T>,
}

pub trait PreviewableIterator<T>: Iterator<Item = T> {
    fn previewable(self) -> PreviewIterator<T, Self>
    where
        Self: Sized,
    {
        PreviewIterator {
            iter: self,
            buffer: VecDeque::new(),
        }
    }
}

impl<T, I> PreviewableIterator<T> for I
where
    I: Iterator<Item = T>,
{
}

impl<'a, T, I> Preview<'a, T, I>
where
    I: Iterator<Item = T> + 'static,
{
    fn next(&mut self) -> Option<&T> {
        self.buffer.push(self.iter.next()?);

        self.buffer.last()
    }
}

impl<'a, T, I> Drop for Preview<'a, T, I>
where
    I: Iterator<Item = T> + 'static,
{
    fn drop(&mut self) {
        self.iter.buffer.extend(self.buffer.drain(..))
    }
}

impl<T, I> Iterator for PreviewIterator<T, I>
where
    I: Iterator<Item = T> + 'static,
{
    type Item = T;

    fn next(&mut self) -> Option<Self::Item> {
        match self.buffer.pop_front() {
            Some(item) => Some(item),
            None => self.iter.next(),
        }
    }
}


impl<T, I> PreviewIterator<T, I>
where
    I: Iterator<Item = T> + 'static,
{
    fn preview(&mut self) -> Preview<T, I>
    where
        Self: Sized,
    {
        Preview {
            buffer: Vec::new(),
            iter: self,
        }
    }
}

struct PowersOfTwo {
    value: usize,
}

impl PowersOfTwo {
    fn new() -> Self {
        PowersOfTwo { value: 2 }
    }
}

impl Iterator for PowersOfTwo {
    type Item = usize;

    fn next(&mut self) -> Option<Self::Item> {
        self.value *= 2;

        Some(self.value)
    }
}

fn main() {
    let mut iter = PowersOfTwo::new().previewable();

    {
        let mut preview = iter.preview();

        println!("previewing: {:?}", preview.next());
        println!("previewing: {:?}", preview.next());
    }

    for value in iter.take(10) {
        println!("{}", value);
    }
}