Iteration through looping constructs is essential for executing code repeatedly when conditions are met or until a task is complete. Rust not only provides familiar looping mechanisms like for and while, but it also introduces powerful constructs unique to the language, enhancing both safety and performance.

Thanks to Rust’s strict ownership model and memory guarantees, iterations in Rust are optimized to minimize runtime errors and ensure predictable behavior. Whether you’re iterating over a collection, controlling program flow, or using iterators for more advanced patterns, understanding Rust’s approach to looping can significantly improve your code’s clarity and efficiency.

Basic Loop (loop construct)

Rust includes the unique loop construct for repeating code. Unlike other looping mechanisms, loop doesn’t, make use of a condition to control when looping stops. You need to explicitly execute the break keyword to exit the loop.

Let’s get started writing some code.

Open a shell window (Terminal on Mac/Linux, Command Prompt or PowerShell on Windows). Then navigate to the directory where you store Rust packages for this blog series, and run the following command:

cargo new looping

Next, change into the newly created looping directory and open it in VS Code (or your favorite IDE).

Note: Using VS Code is highly recommended for following along with this blog series. Be sure to install the Rust Analyzer extension — it offers powerful features like code completion, inline type hints, and quick fixes.

Also, make sure you’re opening the looping directory itself in VS Code. If you open a parent folder instead, the Rust Analyzer extension might not work properly — or at all.

Now, open the file src/main.rs and replace its contents entirely with the following code:

fn main() {
    let mut x = 10;

    loop {
        println!("x is currently: {x}");
        x += 10;

        if x > 50 {
            break;
        }
    }
}

Output:

x is currently: 10
x is currently: 20
x is currently: 30
x is currently: 40
x is currently: 50

We define a mutable variable x with an initial value of 10. Then we enter a loop construct. We print the current value and then increment by 10. When the value is greater than 50 we exit the loop using the break keyword.

Note that although we are not returning a value with the break, as seen in this pseudocode, you can return a value from the loop, and in this case it would be set to variable result.

let result = loop {
    if condition {
        break value;  // The value is returned from the loop
    }
};

The Rust loop construct offers several advantages. Because you must explicitly break to end the loop, the intent of your code flow is more clear, reducing the chance of infinite loops. Also, you can return a value from a loop. Replace the code in main.rs with the following, and execute cargo run:

fn main() {
    let mut x = 10;

    let ending_value = loop {
        println!("x is currently: {x}");
        x += 10;

        if x > 50 {
            break x;
        }
    };

    println!("Ending value is: {:?}", ending_value);
}

This code is similar to our previous code, but we now assign the return value from the loop to a variable ending_value, and we print the value after the loop. We return the value of variable x when we break.

The loop construct is a good choice when you need an infinite loop that ends for a specific reason, and when you want to return a value from the loop cleanly with little extra code.

Now let’s look at other looping mechanisms offered by Rust.

While Loop

The while loop in Rust is similar to other languages, but there are several notable differences.

Like other languages, the condition controlling iteration is checked before entering the while code block. Iteration within the while loop continues until its control condition evaluates to false. The Rust while loop also supports the break and continue keywords, which will be discussed in more detail soon.

One difference is that some languages consider non-zero and non-empty values to be truthy, allowing the loop to continue. Rust is more strict and enforces type safety, only allowing boolean values.

Here is a basic example:

fn main() {
    let mut count = 0;
    
    while count < 5 {
        println!("count is: {}", count);
        count += 1;
    }
}

Rust’s while loop does not return a value directly. If you need to return a value from a loop, use a loop construct with break.

One interesting feature of Rust while loops is the while - let construct:

let mut numbers = vec![1, 2, 3, 4, 5];

while let Some(num) = numbers.pop() {
    println!("Popped: {}", num);
}

This code pops values out of a vector, a collection in Rust, assigning the value to an Option enum Some() variant, and then uses that value in the while code block. Iteration will continue as long as there are values to be popped from the vector.

If you are unfamiliar with Rust enums, the Option enum, and its Some() variant, you may find the ByteMagma post on Rust Enums: Close Cousins of Structs useful.

Note that Rust does not have the do-while loop found in some other languages. Although Rust lacks a do-while loop, you can mimic its behavior using a loop with a conditional break at the end.

let mut x = 5;
loop {
    println!("Value: {}", x);
    x -= 1;
    if x <= 0 {
        break;
    }
}

Next, let’s examine the for loop, another construct found in most other programming languages.

For Loop

On the surface the Rust for loop operates similar to in most other programming languages. The for loop is commonly used when you have a definite set of values to iterate over. But the Rust for construct does have a number of unique features, making it a flexible and powerful choice for iteration.

Let’s look at a simple example:

fn main() {
    for i in 1..5 {
        println!("The value is: {}", i);
    }    
}

This for loop iterates over numbers from 1 to 4 (1..5 is an exclusive range, 1..=5 is an inclusive range), printing out the value in a message.

The Rust for loop is used extensively to iterate over ranges, collections and iterators. The example above involves iteration over a range 1..5, the numbers 1 thru 4.

Behind the scenes, the Rust for loop involves the Iterator and IntoIterator traits. IntoIterator is implemented for arrays, slices, and other collections, converting them into iterators that can be used in a for loop. When using for with collections, the IntoIterator trait is invoked to create an iterator implicitly.

We’ll cover traits in a future post, but for now just understand that that Iterator trait defines the behavior of iterations, and the IntoIterator trait converts a type into an iterator so it can be used with the for construct.

We’ll take a closer look at iterator related methods later in this post, for now understand that iterators are at the heart of the for loop.

Let’s look at iterating over the characters of a string, and also at the topic of ownership when iterating:

fn main() {
    let text = "hello";
    for c in text.chars() {
        println!("{}", c);
    }
    
    let fruits = vec!["apple", "banana", "cherry"];
    for fruit in &fruits {
        println!("I like {}.", fruit);
    }
}

Output:

h
e
l
l
o
I like apple.
I like banana.
I like cherry.

In the first loop we call the chars() method on a string slice (&str) to iterate over the individual characters of the string slice. We’ll take a closer look at the difference between string slices and Strings in a future post. For now just understand that when you assign a string literal like “hello” to a variable, it creates a string slice, not a String.

The chars() method returns an iterator over the characters in a string slice, allowing us to iterate over the characters.

In the second example, the Rust vector collection implements the IntoIterator trait, so when used with a for loop an iterator is created automatically.

Also, notice that our code uses a reference to fruits (&fruits). We do this to ensure that the for loop borrows the fruits vector and does not take ownership. If we did this:

for fruit in fruits {
    println!("I like {}.", fruit);
}

Then the for loop would take ownership of the fruits vector and it would be invalid and unusable after the for loop. If you need more information on ownership in Rust, check out this ByteMagma post: Ownership, Moving, and Borrowing in Rust.

Sometimes you want to iterate over an array and get the values but also the indexes:

fn main() {
    let names = ["Alice", "Bob", "Charlie"];
    for (index, name) in names.iter().enumerate() {
        println!("{}: {}", index, name);
    }
}

In this code we call the iter() method on the array to create an iterator, and then we call the enumerate() method to wrap the iterator and yield a tuple with the index and the value on each iteration. The for construct destructures the tuple into the index and name variables for use in the for loop body.

The destructuring pattern (index, name) allows extracting tuple elements directly within the loop.

Destructuring has many uses in Rust. In the following code, our vector pairs contains elements that are tuples. In our for loop we use destructuring to extract the elements of the tuples into the num and word variables, which can be used in the for loop body.

fn main() {
    let pairs = vec![(1, "one"), (2, "two")];
    for (num, word) in pairs {
        println!("{} is written as {}", num, word);
    }
}

The Iterator trait provides many useful methods. Below we see the filter() method to only take even numbers, and the map() method to perform some action on each element.

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];

    for num in numbers.iter().filter(|&&n| n % 2 == 0) {
        println!("Even number: {}", num);
    }
    
    for doubled in numbers.iter().map(|n| n * 2) {
        println!("Doubled: {}", doubled);
    }
}

You can collect the results of filter() and map() into a new collection using collect().

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

    // Filter out only even numbers
    let even_numbers: Vec<i32> = numbers
        .iter()                    // Create an iterator over the vector
        .filter(|&n| n % 2 == 0)   // Keep only numbers divisible by 2
        .cloned()                  // Clone the filtered values
        .collect();                // Collect the results into a new Vec

    println!("Even numbers: {:?}", even_numbers);
}

A future post will take an in-depth look at many of the Iterator trait methods.

Loop Control – Break and Continue

We saw the break keyword in a couple of code examples in this post. Rust also includes the continue keyword for flow control. These work as they do with most other programming languages with one twist. You can break or continue to a named label.

First let’s look at a simple example of using break and continue.

fn main() {
    let students = vec!["Alice", "Bob", "Absent", "Charlie", "Principal", "Eve"];

    println!("Checking attendance...");

    for student in students.iter() {
        if student == &"Absent" {
            println!("Skipping: {} (not present)", student);
            continue;
        }

        if student == &"Principal" {
            println!("Principal has arrived. Ending attendance check.");
            break;
        }

        println!("Recording attendance for: {}", student);
    }

    println!("Attendance check complete.");
}

This code aims to record student attendance. We have a vector of student names, with a couple of extra string slices used to illustrate break and continue in our loop.

We call iter() on the vector which converts it to an iterator for our loop. We iterate over the vector elements. If we encounter the string literal “Absent”, we print a message and then use the continue keyword to skip the rest of the code in the for loop code block and start the next iteration at the top of the code block.

continue does just that. It causes our code to skip the rest of the code in the loop code block and start the next iteration.

If the element is not “Absent” we move on in the code block and perform another check. If the string literal is “Principal” then we print a different message and use the break keyword to end the for loop. That’s what break does, it ends the loop. We can use break and continue in while and loop constructs as well, and they do the same thing.

If the element is not “Principal” then we move on, printing out student names to record their attendance.

Note how we use references when checking for “Absent” or “Principal”.

if student == &"Absent"

if student == &"Principal"

We use a reference to the vector element to borrow the element and avoid taking ownership, which would prevent the vector from being consumed and allow it to remain accessible after the for loop.

Labels with for Loops

We can attach labels to loops and use those labels with break and continue. Labels are typically used when we have nested loops (loop, while, and for loops) and we want to use break and/or continue to control code flow to a specific loop.

Here is an example:

fn main() {
    let warehouse = vec![
        ("A", vec!["item1", "fragile_item", "item2"]),
        ("B", vec!["item3", "urgent_order", "item4"]),
        ("C", vec!["item5", "item6", "fragile_item"]),
    ];

    let current_temp = 32; // Current warehouse temperature

    'section_loop: for (section, items) in warehouse.iter() {
        println!("Inspecting section: {}", section);

        for item in items {
            if current_temp > 30 && item.contains("fragile") {
                println!("  Skipping fragile item due to high temperature.");
                continue;
            }

            println!("  Checking item: {}", item);

            if item == &"urgent_order" {
                println!("  High-priority item found! Halting search.");
                break 'section_loop;
            }
        }
    }

    println!("Inspection complete.");
}

Output:

Inspecting section: A
  Checking item: item1
  Skipping fragile item due to high temperature.
  Checking item: item2
Inspecting section: B
  Checking item: item3
  Checking item: urgent_order
  High-priority item found! Halting search.
Inspection complete.

This code represents searching a warehouse for items.

Our code begins with a vector representing a warehouse. The vector elements are tuples, each having two elements. The first element of the tuples is an identifier for the warehouse section, A, B, or C. The second element of the tuples is another vector with the items stored in that section of the warehouse.

We define a variable for the temperature in order to identify warehouse conditions that could damage fragile items.

Then we begin a for loop that has the label ‘section_loop. Labels start with a single quote, followed by the label name in lowercase snake_case (all lowercase, words separated by underscores), followed by a colon and a space before the for keyword.

We print that we are inspecting the current section, then we enter a nested for loop. This inner for loop iterates over the items in a section. In the code block for this inner for loop, we check if the temperature is greater than 30 degrees and if the item contains the text “fragile”. If so we print a message and use the continue keyword to skip the rest of the inner loop code block and move to the next iteration of the outer for loop.

If the item is not marked “fragile”, we print a message that we are checking that item, and then check if the item is an urgent order. If the item is urgent then we use the break keyword and a label to break out of the outer loop, and print a message that the inspection is complete. The label used with the break keyword is the same as the label attached to the outer for loop, without the colon ‘section_loop

Note that when you use a continue or break without a label, it will continue or break from the current loop. Together with labels on loops, this gives you very fine grained control over looping.

Caution: don’t overuse labels on loops. They can lead to messy, hard to understand code when you have multiple labels on loops.

Iterating with iter(), into_iter(), and iter_mut()

We’ve learned that Rust for loops operate using iterators behind the scenes. And we’ve seen the iter() method used to create an iterator from an array. Let’s understand this at a deeper level, and look at two more useful methods when using for loops.

In most programming languages, looping over a collection is straightforward:

• You get direct access to elements.
• You can modify them freely if the collection is mutable.
• The original collection remains available after iteration.

But Rust adds a layer of complexity with ownership and borrowing:

• Who owns the data when iterating?
• Can you modify elements while looping?
• Will the collection remain accessible after the loop?

These questions lead to three distinct ways to iterate over a collection in Rust:

iter() – for immutable borrowing

iter_mut() – for mutable borrowing

into_iter() – for consuming the collection

In Rust, iterating over a collection isn’t just about processing elements — it’s about respecting ownership, ensuring memory safety, and preventing accidental modification.

• Immutable Iteration ( iter() ) – Borrow elements without modifying them.
• Mutable Iteration ( iter_mut() ) – Borrow elements mutably and modify them in place.
• Consuming Iteration ( into_iter() ) – Take ownership of the elements and consume the collection.

These three methods allow you to precisely control whether:

• The collection is borrowed or moved.
• Elements can be modified.
• The original collection remains accessible.

Think of a collection as a book:

• iter() – You’re flipping through the pages without writing on them.
• iter_mut() – You’re flipping through and making annotations on the pages.
• into_iter() – You tear out the pages one by one, and once you’re done, the book is gone.

This analogy helps illustrate how these methods determine whether you get a reference to the elements, modify them, or consume them.

Let’s look at an example:

fn main() {
    let mut numbers = vec![1, 2, 3, 4, 5];

    // Using iter() - Borrowing the elements immutably
    for num in numbers.iter() {
        println!("Immutable reference: {}", num);
    }

    // Using iter_mut() - Modifying elements in place
    for num in numbers.iter_mut() {
        *num *= 2;
    }
    println!("After iter_mut: {:?}", numbers);

    // Using into_iter() - Taking ownership and consuming
    for num in numbers.into_iter() {
        println!("Owned value: {}", num);
    }

    // Error: numbers is no longer accessible after into_iter()
    // println!("{:?}", numbers);
}

We start with a vector of numbers. We then have three for loops, each using one of the three methods we’ve been discussing. With iter(), we borrow the items immutably. We can access the data and print it, but we don’t change it.

With iter_mut(), we borrow the items mutably, and we change the data in-place. Notice how we use the dereference operator * to access the data inside the reference produced by iter_mut(), and we use the *= operator to multiply each value by 2.

Finally, with into_iter() we take ownership of the numbers vector, we consume it. That’s why we comment out the println!() at the end of the main() function. Because we took ownership of the numbers vector, it has become invalid an unusable after the for loop.

If you need to understand ownership, borrowing, etc. refer to our ByteMagma post: Ownership, Moving, and Borrowing in Rust.

---

We’ve covered a lot in this post, introducing the Rust looping mechanisms. We saw how looping in Rust is similar to other programming languages, and we pointed out the unique features of loops in Rust.

Thank you so much for visiting, and please keep coming back as you move toward Rust mastery!