Feature request: `skip_last`

[A248]

Add the ability to skip the last item in an iterator.

[jswrenn]

Iterators are streams of values, and their "last value" is, generally speaking, wherever you stop driving iteration.

For fused, peekable iterators, you could iterate until you peek a None.

[A248]

You don't have to tell me what iterators are.

Yes, if it makes more design sense to implement this for peekable iterators, then by all means. I can see why.

[samvv]

Funny I just thought of opening a similar issue.

I realized there's another option: eagerly buffer the iterator for N items. If the N+1th item is empty, we know that we should drop the remaining buffered items, otherwise, pop the first item from the buffer and append the N+1th. A VecDeque seems like the ideal choice.

I'm implementing it in my compiler written in Rust. I'll let you know how it goes.

[samvv]

Here's my attempt. My Rust is not perfect but I tested it on some simple examples and it works. Feel free to test and make adjustments.

pub struct SkipLast<I: Iterator> {
    buffer: VecDeque<I::Item>,
    iter: I,
    count: usize,
}

impl <I: Iterator> Iterator for SkipLast<I> {
    type Item = I::Item;
    fn next(&mut self) -> Option<Self::Item> {
        while self.buffer.len() <= self.count {
            match self.iter.next() {
                None => {
                    // More items to drop than to return
                    self.buffer.clear();
                    return None;
                }
                Some(item) => {
                    self.buffer.push_back(item);
                }
            }
        }
        // If we arrived here, always present
        self.buffer.pop_front()
    }
}

pub trait IterExt : Iterator {
    fn skip_last(self, n: usize) -> SkipLast<Self> where Self: Sized {
        SkipLast {
            buffer: VecDeque::new(),
            iter: self,
            count: n,
        }
    }
}

impl<T> IterExt for T where T: Iterator + ?Sized {}

[ronnodas]

@A248 Maybe dropping_back() works for what you want?

[ronnodas]

I think the only way to do this generically and lazily is to drop the last n elements the first time either next() or next_back(), or any other non-default-implementation method, is called. Since different DoubleEndedIterators have different internal ways to prevent the two ends from going past each other, this is the only way to tell the inner iterator to stop the forward iteration before yielding the last n elements. But there's not much you can do with an iterator without mutating it, so I'm having trouble coming up with a situation where this is better than dropping_back().

Note that std::iter::Skip<I> only implements DoubleEndedIterator when I: DoubleEndedIterator + ExactSizeIterator. In that case, there's iter.rev().skip(n).rev(). The main reason for this restriction is the potentially unexpected order of iteration for the inner iterator, which also applies to skip_last().