next method

Drain elements one by one with next.

The next method

next can be called by hand too. The iterator variable must be mut, because each call advances it; an exhausted iterator keeps returning None:

let v = vec!["a", "b"];
let mut it = v.iter();
println!("{:?}", it.next());   // Some("a")
println!("{:?}", it.next());   // Some("b")
println!("{:?}", it.next());   // None

A for loop does exactly this behind the scenes: it calls next until None.

Consuming methods

Some methods consume the iterator by calling next to the end and produce a result: sum, count, collect, last, max. A consumed iterator can't be used again (it has been moved):

let it = vec![1, 2, 3].into_iter();
let toplam: i32 = it.sum();
// it.count();   // error: it was moved into sum
println!("{toplam}");   // 6

nth(n) and find advance the iterator only as far as needed.

Exercise Advancing by hand

For let v = vec!["a", "b"];, create let mut it = v.iter(); and call next() three times, printing the results with {:?} on one line.

Show example solution

fn main() {
    let v = vec!["a", "b"];
    let mut it = v.iter();
    let a = it.next();
    let b = it.next();
    let c = it.next();
    println!("{:?} {:?} {:?}", a, b, c);
}

Test yourself

What do <code>iter()</code>, <code>iter_mut()</code> and <code>into_iter()</code> produce, in order?
- &T, &T, &T
- T, &mut T, &T
- &T, &mut T, T
- T, T, T
Show answer

&T, &mut T, T — into_iter consumes the collection and gives ownership of the elements.

Advance

let mut it = v.iter();
let ilk = it.____();

Show answer

let mut it = v.iter();
let ilk = it.next();

Method and result on [1, 2, 3]

.iter().count()

3
.iter().last()

Some(3)
.iter().nth(1)

Some(2)
.iter().nth(5)

None

Next lesson: map and filter

We Are Enhancing Your Experience

Cookie Preferences

Strictly Necessary Cookies

Analytical Cookies