`std::slice::ChunkBy` should implement `Clone`

[nwoods-cimpress]

I tried this code:

pub fn main() {
    let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
    let mut iter = slice.chunk_by(|a, b| a == b);
    assert_eq!(iter.next(), Some(&[1, 1, 1][..]));
    assert_eq!(iter.next(), Some(&[3, 3][..]));

    let mut iter_clone = iter.clone();
    assert_eq!(iter_clone.next(), Some(&[2, 2, 2][..]));
    assert_eq!(iter_clone.next(), None);

    assert_eq!(iter.next(), Some(&[2, 2, 2][..]));
    assert_eq!(iter.next(), None);
}

I expected to see this happen: Code compiles and runs

Instead, this happened: Compilation error by virtue of std::slice::ChunkBy not implementing Clone

If there is a reason that Clone cannot be supported, I don't understand it.

[gstjepan2]

I assume you meant iter.cloned() instead of iter.clone() method, because .clone method doesn't exist on ChunkBy.

The reason .cloned() method exists on ChunkBy but can't be used in that example is because its implemented by default on Iterator trait, but it clause isn't satisfied.

Not sure if this is what you want, but you can try this:

pub fn main() {
    let slice = &[1, 1, 1, 3, 3, 2, 2, 2];
    let mut iter = slice
        .chunk_by(|a, b| a == b)
        .map(Vec::from)
        .collect::<Vec<_>>()
        .into_iter();

    assert_eq!(iter.next(), Some(vec![1, 1, 1]));
    assert_eq!(iter.next(), Some(vec![3, 3]));

    let mut iter_clone = iter.clone();
    assert_eq!(iter_clone.next(), Some(vec![2, 2, 2]));
    assert_eq!(iter_clone.next(), None);

    assert_eq!(iter.next(), Some(vec![2, 2, 2]));
    assert_eq!(iter.next(), None);
}

[compiler-errors]

I assume you meant iter.cloned() instead of iter.clone() method, because .clone method doesn't exist on ChunkBy.

I think that's exactly what they're asking for, which is why ChunkBy doesn't implement the Clone trait.

[theemathas]

I believe they actually meant clone. Some iterators in std implement Clone, for example std::vec::IntoIter and std::iter::Filter. The expected behavior of cloning iterators is that it produces an independent iterator that produces the same series of elements. I believe that the fact that ChunkBy doesn't implement Clone is an oversight.

[nwoods-cimpress]

Correct; I want clone(), not cloned(). I don't want to duplicate the underlying data; just the state of the iterator.

Here is a permalink showing an equivalent to what I want, but using Itertools::coalesce(). This does indeed work, but it is much more verbose and less convenient than chunk_by().

[compiler-errors]

@nwoods-cimpress: I think you can just add the clone impl in a PR and it will get FCP'd (team consensus voting) by T-libs-api, but if you want to be extra diligent you could 1. find the PR that added the ChunkBy iterator to find out if this was an oversight or intentional, and 2. use blame/history to find another PR that added a Clone impl to an iterator "after the fact" and compare what process they went through to add it.

[nwoods-cimpress]

PR #138016 submitted. First PR to core Rust; hopefully I got the protocol correct 🤞

[thaliaarchi]

For context, this was reported on Reddit: https://www.reddit.com/r/rust/comments/1j2sx86/why_is_the_iterator_returned_by_slicechunk_by_not/