By the time you walk out of here, you should understand what iterators are good for, how they work internally, and how to create your own!

Iterators are a fairly central concept to Rust. If you're looping over something, you're very likely already using an iterator. If you're transforming collections, you probably 

 using them. If your function returns a lazily evaluated sequence of things, you should consider returning an iterator - especially if that sequence could be lazily evaluated.

We'll take a look at how iterators are implemented, how to iterate over a collection, what sorts of iterators exist in the standard library, usage and common patterns for transforming data, and finally a few examples of useful crates that provide their functionality via powerful iterators.

Skill-wise, you'll ideally have an understanding of

I highly recommend having some sort of environment to run snippets of code in. The simplest thing to use is the 

. If you'd like a local environment, refer to 

Essentially, an iterator is a thing that allows you to traverse some sort of a sequence. Note that since Rust's iterators are lazy, this sequence could be generated on the fly - you could just as well traverse an existing array of finite length or create an iterator that keeps spewing out random numbers infinitely.

 in programming is this general idea of delaying a computation until it's actually needed. A lazy iterator doesn't need to know all the elements it's going to return when it's first initialized - it can compute every next element when/if it's asked for.

In Rust, iterators are typically implemented using the 

 trait. All we need to implement that trait for our custom type is provide an associated type 

 (this is the type of the elements of the sequence, returned by the iterator) and the 

Let's try and implement an iterator over numbers from 1 to 10.

/// An iterator that returns numbers from 1 to 10.
struct OneToTen {
    current: u32,
}

impl OneToTen {
    /// Constructor for OneToTen.
    fn new() -> Self {
        Self {
            current: 0,
        }
    }
}

impl Iterator for OneToTen {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        None // we'll change this in a second...
    }
}

 method is expected to yield the next element of the sequence. It takes a mutable reference to 

 in case we need to keep track of some state between 

 calls, which is normally the case. We'll soon find it useful.

. If an iterator is finite, it needs to return 

 to indicate it has no more elements to return. Right now, this iterator will immediately finish, not yielding any items. Let's fix this.

impl Iterator for OneToTen {
    type Item = u32;
    
    fn next(&mut self) -> Option<Self::Item> {
        if self.current < 10 {
            self.current += 1;
            return Some(self.current);
        }
        
        None
    }
}

This should be pretty self-explanatory. Every call to 

So we have an iterator. Let's use it. The most basic thing we can do is simply loop over all of its elements:

fn main() {
    for i in OneToTen::new() {
        println!("{}", i);
    }
}

 is what you get when you type something like 

. Instead of writing the above custom iterator, we could have simply done this:

fn main() {
    for i in 1..11 {
        println!("{}", i);
    }
}

Sometimes you'll want to provide the user of your code the ability to iterate over your type, but without that type itself being an iterator. This will be the case with collections. If you implement your own vector type, you probably don't want that type to needlessly hold an extra iteration variable just in case someone wants to iterate over it.

What we want is a way to create an iterator out of the collection. There are three mechanisms you'll typically see.

If we want to iterate over a vector of chars, we could do something like this:

fn main() {
    let v = vec!('a', 'b', 'c');
    
    for c in v.into_iter() {
        println!("{}", c);
    }
}

 call, Rust will call that method implicitly anyway.

fn main() {
    let v = vec!('a', 'b', 'c');
    
    for c in v {
        println!("{}", c);
    }
}

This implicit call is important to keep in mind. Since 

 consumes the data, we cannot use the original vector later.

fn main() {
    let v = vec!('a', 'b', 'c');
    
    for c in v {
        println!("{}", c);
    }
    
    println!("{:?}", v);
    // error: borrow of moved value: `v`
}

One solution would be to explicitly call 

 so that the iterator is borrowing instead. Another is to provide a reference to 

fn main() {
    let v = vec!('a', 'b', 'c');
    
    for c in &v {
        println!("{}", c);
    }
    
    println!("{:?}", v);
}

This way, the compiler can no longer implicitly call 

 since it doesn't get an owned value. It gets an immutable reference, so the best it can do is implicitly call 

Then there's mutability. Following the same pattern, here Rust will implicitly call 

 and give us an iterator that is mutably borrowing.

fn main() {
    let mut v = vec!('a', 'b', 'c');
    
    for c in &mut v {
        *c = 'z';
    }
    
    println!("{:?}", v);
}

If all you could do with iterators was loop over them with the 

 keyword, they wouldn't be all that useful. But there is a plethora of adapters that transform an iterator into another kind of iterator, altering its behavior.

Most adapters you'll work with are in the standard library and exist as 

methods provided for the implementers of the 

. There are some crates out there (such as 

) that provide extra adapters via extensions.

We're going to go through a few useful adapters, but I highly recommend taking a look at the full list in 

We can construct an infinite iterator using 

. It would be a bad idea to iterate over it directly.

fn main() {  
  	// brace for timeout!
    for i in std::iter::repeat(1) {
        println!("{}", i);
    }
}

If we wanted to print only a few 1s, however, we can use the 

fn main() {  
    for i in std::iter::repeat(1).take(5) {
        println!("{}", i);
    }
}

 is also an iterator, but this one finishes after returning a set number of elements.

A very typical feature of functional programming is the ability to 

, that is to apply a function to every element of a sequence.

fn main() {  
    let pairs = [(1, 2), (3, 4), (5, 6)].iter();
    
    /// Provides the sum of a pair.
    fn sum_tuple((x, y): &(u32, u32)) -> u32 {
        x + y
    }
    
    /// Iterate over sums of our pairs.
    for sum in pairs.map(sum_tuple) {
        println!("{}", sum);
    }
}

If we wanted to find only elements that fulfill a certain criterion, we can use the 

fn main() {  
    let numbers = [9, 3, 8, 25].iter();
    
    for num in numbers.filter(|x| **x > 8) {
        println!("{}", num);
    }
}

We know how to turn a collection into an iterator. How do we turn an iterator into a collection? Enter the 

We could try to convert from a vector to an iterator and back.

fn main() {
    // Create a vector and turn it into an iterator.
    let vec_iter = vec!('a', 'b', 'c').into_iter();
    // Collect the elements into a vector again.
    let new_vec = vec_iter.collect();
    
    println!("{:?}", new_vec);
}

error[E0282]: type annotations needed
 --> src/main.rs:5:9
  |
5 |     let new_vec = vec_iter.collect();
  |         ^^^^^^^ consider giving `new_vec` a type

What Rust is telling us here is that it doesn't know what we're trying to collect into. 

 has a generic return type and could give you a number of things: a vector, a linked list, a string, etc. You could even create a custom type that can be collected into.

To let Rust know what concrete type we want 

let new_vec = vec_iter.collect::<Vec<char>>();

We can make this slightly shorter. The compiler should be able to figure out that we want a vector of chars, specifically, and not a vector of integers. When filling out type parameters, we can use an underscore to tell Rust, "Figure this part out yourself!"

In a case like this, you might find it tidier to add a type annotation to the variable declaration instead. The whole thing will then look like this:

fn main() {
    // Create a vector and turn it into an iterator.
    let vec_iter = vec!('a', 'b', 'c').into_iter();
    // Collect the elements into a vector again.
    let new_vec: Vec<_> = vec_iter.collect();
    
    println!("{:?}", new_vec);
}

, we can convert an array of chars into a string.

fn main() {
    let s: String = ['a', 'b', 'c'].iter()
        .collect();
    
    println!("{}", s);
}

We could also collect an iterator of tuples (where the first element needs to be hashable) into a 

use std::collections::HashMap;

fn main() {
    let tuples = vec![("abc", 5), ("def", 11)].into_iter();
    let hash_map: HashMap<_, _> = tuples.collect();
    
    println!("{:?}", hash_map);
}

Things that can be collected into implement the 

 trait. That means this behavior is extendable! Check out the 

 to see which types can be collected into and how to implement new ones.

We now have some idea of how iterators work and some operations we can perform on them. Let's put it together and see some typical use cases.

 structs, which include a customer's name, e-mail address, and how much they owe us.

struct Customer<'e> {
    email: &'e str,
    owed: f64,
}

impl<'e> Customer<'e> {
    fn new(email: &'e str, owed: f64) -> Self {
        Self {
            email,
            owed,
        }
    }
}

Then let's say we have a list of such customers. We're tasked with producing a vector of all debtor e-mails so we can send them a generic reminder.

fn main() {
    let customers = vec![
        Customer::new("andrew@stuff.eu", 0.0),
        Customer::new("brandy@stuff.eu", 4.23),
        Customer::new("chevonne@stuff.eu", 23.33),
    ];
    
    let debtor_emails: Vec<&str>; // Transform the data here!
    println!("{:?}", debtor_emails);
}

How do we do it? The nice, idiomatic way is to get an iterator over 

, apply some adapters that will filter and transform the data, and then collect that back into a vector.

fn main() {
    let customers = vec![
        Customer::new("andrew@stuff.eu", 0.0),
        Customer::new("brandy@stuff.eu", 4.23),
        Customer::new("chevonne@stuff.eu", 23.33),
    ];
    
    let debtor_emails: Vec<&str> = customers.iter()
        .filter(|c| c.owed > 0.0) // only debtors
        .map(|c| c.email) // get the e-mails
        .collect(); // collect into a vector
    println!("{:?}", debtor_emails);
}

 struct as above, and the same vector of customers, we can search the customer data for a specific person. There's no useful method defined directly on the 

    let brandy = customers.iter()
        .find(|c| c.email == "brandy@stuff.eu")
        .unwrap();
    
    println!("{:?}", brandy);

What if we'd like to get the position of an element in the vector? Things get a little trickier, but create an iterator.

 will wrap every element in a tuple of formthe the  

 closure a little to account for the items now being tuples.

we still have to extract the position component of the tuple, which is the 0th one.

    let brandy_pos = customers.iter()
        .enumerate()
        .find(|(_, c)| c.email == "brandy@stuff.eu")
        .unwrap()
        .0;
        
    println!("{}", brandy_pos);

 method that yields an iterator over chunks of that string. All you have to provide is a pattern to split by - commonly a 

For example, you could get all the words of a phrase this way:

fn main() {
    let s = "fe fi fo fum";
    let words = s.split(' ');
  
    for word in words {
        println!("{}", word);
    }
}

And then you could transform them and collect them into a new 

fn main() {
    let s = "fe fi fo fum";
    let new_s: String = s.split(' ')
        .rev()
        .collect();
        
    println!("{}", new_s);
}

 method is an adapter that reverses an iterator!

These are some examples of third-party libraries providing some functionality via iterators.

This just about exhausts the core concepts and basic usage. Hopefully, you should now be able to not only effectively transform collections, but (with some practice) also identify where providing iterators would make sense in your code.

Learn

The newline Guide to Building Your First GraphQL Server with Node and TypeScript

Teach

Amelia Wattenberger

Author of Fullstack D3

Community

Rust Iterators: A Guide

Responses (1)

Masterclasses

Tutorials

Fullstack React with TypeScript