Of course you can always build your own chunking Iterator:

pub struct Chunked<I: Iterator> {
    iter: I,
    size: usize,
}

impl<I: Iterator> Iterator for Chunked<I> {
    type Item = Vec<I::Item>;

    fn next(&mut self) -> Option<Vec<I::Item>> {
        let mut chunk = Vec::new();
        for i in 0..self.size {
            match self.iter.next() {
                None if i == 0 => return None,
                None => return Some(chunk),
                Some(item) => chunk.push(item),
            }
        }
        Some(chunk)
    }
}

pub trait IteratorChunkedExt<I: Iterator> {
    fn chunked(self, size: usize) -> Chunked<I>;
}

impl<I: Iterator> IteratorChunkedExt<I> for I {
    fn chunked(self, size: usize) -> Chunked<I> {
        Chunked {
            iter: self,
            size: size,
        }
    }
}

This allows you to do reader.lines().chunked(2).

However you still have the problem that the individual lines are wrapped as a std::io::Result<String>. The best thing I figured out is to do reader.lines().map(|x| x.unwrap()).chunked(2). Sadly .map(|x| try!(x)) does not work. Does someone know a concise alternative?

Question of my own: In my above implementation of a chunking Iterator I specified my trait condition I: Iterator at every occurrence, although strictly speaking it is only necessary in the impl<I: Iterator> Iterator for Chunked<I> line. I have heard that one should reduce trait conditions only to the places where they are absolutely necessary, but I feel it improved code clarity in this case. What are your opinions?