ArrayChunks::into_remainder does not return None when there is no remainder

[hkBst]

I tried this code:

#![feature(iter_array_chunks)]

fn main() {
    let line = "abc";
    let mut chunks = line.chars().array_chunks::<3>();
    let _result: Vec<_> = chunks.by_ref().collect();
    if let Some(rem) = chunks.into_remainder() {
        assert!(rem.count() != 0);
    }
}

I expected to see this happen: into_remainder returns None when there is no remainder

Instead, this happened: into_remainder returns Some of an iterator with zero elements

[zirconium-n]

Should we even return an Option here? Maybe we can just scrap that so returning an iterator with zero elements is the expected output?

Similiar API does not return an Option.

[rossmacarthur]

Should we even return an Option here? Maybe we can just scrap that so returning an iterator with zero elements is the expected output?

I think it is worth returning Option because it forces the user to consider that the remainder might not be known yet. Because we can't know the remainder until the iterator has been consumed.

In the slice case, the remainder can always be calculated because it has a length.

[hkBst]

@rossmacarthur Perhaps I am misunderstanding you here, but it seems that you are saying that None is used as an error value for the case where the iterator was not exhausted when into_remainder was called. Perhaps naively, I assumed that into_remainder would return whatever remained of the original iterator after however many chunks were consumed (and I can see now how the "remaining elements of the original iterator that are not going to be returned by this iterator" is supposed to be interpreted). With this interpretation the remainder is always obvious and there is no need for an Option. For slices it is possible to determine the remainder-after-consuming-all-chunks even when all chunks have not yet been consumed and this has been exposed in the API, but perhaps that was a mistake? Or perhaps it was a mistake for into_remainder to mimic remainder in this case.

[melvdlin]

I think it is worth returning Option because it forces the user to consider that the remainder might not be known yet. Because we can't know the remainder until the iterator has been consumed.

The current implementation does not do this; iter::ArrayChunks::into_remainder always exhausts the iterator, it cannot ever return None. Regardless of whether we want into_remainder to be fallible or not, the current behaviour is very misleading.

[rossmacarthur]

Looks like this was changed in #123406, possibly the function can now just return array::IntoIter<I::Item, N>