CODEWITHSUNDEEP
rustiterator
Aster
Aster

Reputation: 142

How to create a iter repeats last element in rust

How to create a iter repeats last element?

for example:

[1, 2, 3] => [1, 2, 3, 3, 3, ...]

My attempt:

fn main() {
    let v = vec![1, 2, 3];
    let mut vi = v.iter().chain(repeat(v[v.len()]));
    println!("{}", vi.next().unwrap())
}

error[E0271]: type mismatch resolving `<std::iter::Repeat<{integer}> as std::iter::IntoIterator>::Item == &{integer}`
   --> projects\notedown-ast\src\traits\to_html.rs:120:27
    |
120 |     let mut vi = v.iter().chain(repeat(v[v.len()]));
    |                           ^^^^^ expected integer, found `&{integer}`

error[E0599]: no method named `next` found for struct `std::iter::Chain<std::slice::Iter<'_, {integer}>, std::iter::Repeat<{integer}>>` in the current scope
   --> projects\notedown-ast\src\traits\to_html.rs:121:23
    |
121 |     println!("{}", vi.next().unwrap())
    |                       ^^^^ method not found in `std::iter::Chain<std::slice::Iter<'_, {integer}>, std::iter::Repeat<{integer}>>`
    |
    = note: the method `next` exists but the following trait bounds were not satisfied:
            `std::iter::Chain<std::slice::Iter<'_, {integer}>, std::iter::Repeat<{integer}>> : std::iter::Iterator`

error: aborting due to 2 previous errors

Upvotes: 1

Views: 1001

Answers (2)

Boiethios
Boiethios

Reputation: 42759

Here is a generalized implementation:

struct LastRepeatIter<I>
where
    I: Iterator,
    I::Item: Clone,
{
    it: I,
    next: Option<I::Item>,
    last: bool,
}

impl<I> LastRepeatIter<I>
where
    I: Iterator,
    I::Item: Clone,
{
    fn new<It>(it: It) -> Self
    where
        It: IntoIterator<IntoIter = I, Item = I::Item>,
    {
        LastRepeatIter {
            it: it.into_iter(),
            next: None,
            last: false,
        }
    }
}

impl<I> Iterator for LastRepeatIter<I>
where
    I: Iterator,
    I::Item: Clone,
{
    type Item = I::Item;

    fn next(&mut self) -> Option<Self::Item> {
        if !self.last {
            match self.it.next() {
                None => self.last = true,
                Some(next) => self.next = Some(next),
            }
        }

        self.next.clone()
    }
}

#[test]
fn it_works() {
    let mut it = LastRepeatIter::new(vec![1, 2, 3]);

    assert_eq!(it.next(), Some(1));
    assert_eq!(it.next(), Some(2));
    assert_eq!(it.next(), Some(3));
    assert_eq!(it.next(), Some(3));
    assert_eq!(it.next(), Some(3));
}

At each iteration, the code checks if there is a next item:

  • if there is one, next is stored inside the next field,
  • if there is none, the last flag is put at true.

Upvotes: 2

edwardw
edwardw

Reputation: 13942

v.iter() is an iterator of references whereas repeat is of values themselves. Plus, the last element of a vector is v[v.len() - 1].

To make it work:

use std::iter::repeat;

fn main() {
    let v = vec![1, 2, 3];
    let mut vi = v.iter().chain(repeat(&v[v.len() - 1]));
    println!("{}", vi.nth(10).unwrap());
}

Upvotes: 2

Related Questions