Introduction to For Loops in Rust

For loops are fundamental control flow structures used for iterating over collections, ranges, and any type that implements the Iterator trait. Rust's for loops are designed to be safe, expressive, and efficient, leveraging the language's ownership system and iterator abstractions. Understanding for loops is crucial for writing idiomatic and performant Rust code.

Key Concepts

• Iterator-based: For loops work with any type implementing IntoIterator
• Ownership awareness: Control over borrowing vs consuming
• Zero-cost abstractions: Iterators compile to efficient loop code
• Pattern matching: Destructuring in loop variables
• Range expressions: Concise syntax for numeric sequences

1. Basic For Loop Syntax

Simple Range Iteration

fn main() {
// Basic range (exclusive end)
for i in 0..5 {
println!("i = {}", i);  // Prints 0, 1, 2, 3, 4
}
// Inclusive range (..=)
for i in 0..=5 {
println!("i = {}", i);  // Prints 0, 1, 2, 3, 4, 5
}
// Reverse range
for i in (0..5).rev() {
println!("i = {}", i);  // Prints 4, 3, 2, 1, 0
}
// Step by (using step_by)
for i in (0..=10).step_by(2) {
println!("Even: {}", i);  // Prints 0, 2, 4, 6, 8, 10
}
}

For Loop with Collections

fn main() {
// Arrays
let arr = [1, 2, 3, 4, 5];
for element in arr {
println!("Element: {}", element);
}
// Vectors
let vec = vec!["apple", "banana", "orange"];
for fruit in vec {
println!("Fruit: {}", fruit);
}
// println!("{:?}", vec); // Error: vec moved
// Slices
let slice = &[1, 2, 3, 4, 5];
for num in slice {
println!("Number: {}", num);  // num is &i32
}
// Strings (as chars)
let text = "hello";
for c in text.chars() {
println!("Char: {}", c);
}
// Strings (as bytes)
for b in text.bytes() {
println!("Byte: {}", b);
}
}

2. Iterating Over References

Borrowing in For Loops

fn main() {
let numbers = vec![1, 2, 3, 4, 5];
// Immutable borrow (default for Vec)
for num in &numbers {
println!("num: {}", num);  // num is &i32
}
println!("Still have numbers: {:?}", numbers);
// Explicitly borrow
for num in numbers.iter() {
println!("num: {}", num);  // num is &i32
}
println!("Still have numbers: {:?}", numbers);
// Mutable borrow
let mut mutable_numbers = vec![1, 2, 3, 4, 5];
for num in &mut mutable_numbers {
*num *= 2;  // Modify in place
}
println!("Modified: {:?}", mutable_numbers);
// Into_iter consumes
for num in numbers.into_iter() {
println!("num: {}", num);  // num is i32 (owned)
}
// println!("{:?}", numbers); // Error: numbers moved
}

Iterating with Enumerate

fn main() {
let fruits = vec!["apple", "banana", "orange"];
// Get index and value
for (index, fruit) in fruits.iter().enumerate() {
println!("{}: {}", index, fruit);
}
// With mutable values
let mut scores = vec![10, 20, 30];
for (i, score) in scores.iter_mut().enumerate() {
*score += i as i32 * 5;
}
println!("Modified scores: {:?}", scores);
// Custom starting index
for (i, fruit) in fruits.iter().enumerate() {
println!("{}: {}", i + 1, fruit);  // Start at 1
}
}

3. Pattern Matching in For Loops

Destructuring in Loops

fn main() {
// Tuples in vector
let points = vec![(1, 2), (3, 4), (5, 6)];
for (x, y) in points {
println!("Point: ({}, {})", x, y);
}
// Structs
struct Person {
name: String,
age: u32,
}
let people = vec![
Person { name: "Alice".to_string(), age: 30 },
Person { name: "Bob".to_string(), age: 25 },
];
for Person { name, age } in people {
println!("{} is {} years old", name, age);
}
// Enums
enum Color {
RGB(u8, u8, u8),
Hex(String),
}
let colors = vec![
Color::RGB(255, 0, 0),
Color::Hex("#00FF00".to_string()),
];
for color in colors {
match color {
Color::RGB(r, g, b) => println!("RGB: {},{},{}", r, g, b),
Color::Hex(h) => println!("Hex: {}", h),
}
}
}

Ignoring Values

fn main() {
// Ignore index
let items = vec!["a", "b", "c"];
for (_, item) in items.iter().enumerate() {
println!("Item: {}", item);
}
// Ignore some tuple elements
let records = vec![(1, "Alice", 30), (2, "Bob", 25)];
for (_, name, _) in records {
println!("Name: {}", name);
}
// Ignore with pattern
let options = vec![Some(1), None, Some(3)];
for opt in options {
if let Some(val) = opt {
println!("Value: {}", val);
}
// None values are ignored
}
}

4. Advanced Iteration Techniques

Chaining Iterators

fn main() {
// Chain two iterators
let v1 = vec![1, 2, 3];
let v2 = vec![4, 5, 6];
for i in v1.iter().chain(v2.iter()) {
println!("Chained: {}", i);
}
// Zip iterators
let names = vec!["Alice", "Bob", "Charlie"];
let ages = vec![30, 25, 35];
for (name, age) in names.iter().zip(ages.iter()) {
println!("{} is {} years old", name, age);
}
// Zip with different lengths
let short = vec![1, 2];
let long = vec![1, 2, 3, 4];
for pair in short.iter().zip(long.iter()) {
println!("Pair: {:?}", pair);  // Stops when shortest ends
}
// Cycle (repeat forever)
let pattern = vec!["red", "green", "blue"];
for color in pattern.iter().cycle().take(7) {
println!("Color: {}", color);
}
}

Filtering and Transforming

fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6];
// Filter
for even in numbers.iter().filter(|&&x| x % 2 == 0) {
println!("Even: {}", even);
}
// Map (transform)
for squared in numbers.iter().map(|&x| x * x) {
println!("Squared: {}", squared);
}
// Filter map (combine filter and map)
let words = vec!["1", "2", "three", "4", "five"];
for num in words.iter().filter_map(|w| w.parse::<i32>().ok()) {
println!("Parsed number: {}", num);
}
// Flat map
let nested = vec![vec![1, 2], vec![3, 4], vec![5, 6]];
for num in nested.iter().flatten() {
println!("Flattened: {}", num);
}
}

Skipping and Taking

fn main() {
let numbers = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// Take first n elements
for num in numbers.iter().take(3) {
println!("Take: {}", num);  // 1, 2, 3
}
// Skip first n elements
for num in numbers.iter().skip(5) {
println!("Skip: {}", num);  // 6, 7, 8, 9, 10
}
// Skip while condition true
for num in numbers.iter().skip_while(|&&x| x < 5) {
println!("Skip while: {}", num);  // 5, 6, 7, 8, 9, 10
}
// Take while condition true
for num in numbers.iter().take_while(|&&x| x < 5) {
println!("Take while: {}", num);  // 1, 2, 3, 4
}
// Step by
for num in numbers.iter().step_by(2) {
println!("Step by 2: {}", num);  // 1, 3, 5, 7, 9
}
}

5. Loop Control Flow

Break and Continue

fn main() {
// Break - exit loop early
for i in 0..10 {
if i == 5 {
break;
}
println!("Break example: {}", i);  // Prints 0-4
}
// Continue - skip to next iteration
for i in 0..10 {
if i % 2 == 0 {
continue;  // Skip even numbers
}
println!("Continue example: {}", i);  // Prints odd numbers
}
// Break with value (in loop, not for loop)
let mut i = 0;
let result = loop {
i += 1;
if i == 10 {
break i * 2;  // Return value from loop
}
};
println!("Loop result: {}", result);
}

Loop Labels

fn main() {
// Labeled break for nested loops
'outer: for i in 1..=3 {
for j in 1..=3 {
if i == 2 && j == 2 {
break 'outer;  // Breaks outer loop
}
println!("i: {}, j: {}", i, j);
}
}
// Labeled continue
'outer2: for i in 1..=3 {
for j in 1..=3 {
if i == 2 && j == 2 {
continue 'outer2;  // Continues outer loop
}
println!("i: {}, j: {}", i, j);
}
}
// Practical example: searching in 2D
let matrix = vec![
vec![1, 2, 3],
vec![4, 5, 6],
vec![7, 8, 9],
];
let target = 5;
let mut found_at = None;
'search: for (i, row) in matrix.iter().enumerate() {
for (j, &value) in row.iter().enumerate() {
if value == target {
found_at = Some((i, j));
break 'search;
}
}
}
println!("Found at: {:?}", found_at);
}

6. For Loops with Ranges

Range Types

fn main() {
// Range (start..end) - exclusive
let range = 1..5;
for i in range {
println!("Range: {}", i);  // 1, 2, 3, 4
}
// Range inclusive (start..=end)
let inclusive = 1..=5;
for i in inclusive {
println!("Inclusive: {}", i);  // 1, 2, 3, 4, 5
}
// Range from (start..)
let from = 3..;
for i in from.take(3) {
println!("From: {}", i);  // 3, 4, 5
}
// Range to (..end)
let to = ..5;
for i in to.start.unwrap_or(0)..5 {
println!("To: {}", i);  // 0, 1, 2, 3, 4
}
// Full range (..)
let full = ..;
// Can't iterate directly, needs context
}

Custom Range Iteration

fn main() {
// Characters range
for c in 'a'..='z' {
print!("{} ", c);
if c == 'e' { break; }  // Prevent too much output
}
println!();
// Step by with characters (via conversion)
for c in ('a'..='z').step_by(2) {
print!("{} ", c);
if c == 'e' { break; }
}
println!();
// Reverse ranges
for i in (1..=5).rev() {
println!("Reverse: {}", i);  // 5, 4, 3, 2, 1
}
// Combining ranges with other iterators
let sum: i32 = (1..=10).sum();
println!("Sum 1 to 10: {}", sum);
let product: i32 = (1..=5).product();
println!("Product 1 to 5: {}", product);
}

7. Performance Considerations

Avoiding Allocations

fn main() {
// Bad: Creates intermediate Vec
let numbers = vec![1, 2, 3, 4, 5];
let doubled: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
for num in doubled {
println!("Doubled: {}", num);
}
// Good: Process without allocation
for num in numbers.iter().map(|&x| x * 2) {
println!("Doubled: {}", num);
}
// Bad: Collecting when not needed
let even: Vec<_> = numbers.iter().filter(|&&x| x % 2 == 0).collect();
for num in even {
println!("Even: {}", num);
}
// Good: Filter without collecting
for num in numbers.iter().filter(|&&x| x % 2 == 0) {
println!("Even: {}", num);
}
}

Loop Optimizations

fn main() {
// C-style loop (sometimes faster for simple counters)
let mut sum = 0;
for i in 0..1000000 {
sum += i;
}
println!("Sum: {}", sum);
// While loop equivalent
let mut i = 0;
let mut sum2 = 0;
while i < 1000000 {
sum2 += i;
i += 1;
}
println!("Sum2: {}", sum2);
// Using iterators with optimizations
let data = vec![1, 2, 3, 4, 5];
// These are usually optimized to similar code
// Version 1: for loop
let mut sum3 = 0;
for &x in &data {
sum3 += x;
}
// Version 2: iterator
let sum4: i32 = data.iter().sum();
println!("Sum3: {}, Sum4: {}", sum3, sum4);
}

Cache-Friendly Loops

fn main() {
// Cache-friendly: sequential access
let matrix = vec![vec![0; 1000]; 1000];
// Good: Row-major order
let start = std::time::Instant::now();
for i in 0..1000 {
for j in 0..1000 {
let _ = matrix[i][j];
}
}
println!("Row-major: {:?}", start.elapsed());
// Bad: Column-major order (cache misses)
let start = std::time::Instant::now();
for j in 0..1000 {
for i in 0..1000 {
let _ = matrix[i][j];
}
}
println!("Column-major: {:?}", start.elapsed());
}

8. For Loops with Custom Types

Implementing IntoIterator

struct Range {
start: i32,
end: i32,
}
impl IntoIterator for Range {
type Item = i32;
type IntoIter = RangeIterator;
fn into_iter(self) -> Self::IntoIter {
RangeIterator {
current: self.start,
end: self.end,
}
}
}
struct RangeIterator {
current: i32,
end: i32,
}
impl Iterator for RangeIterator {
type Item = i32;
fn next(&mut self) -> Option<Self::Item> {
if self.current < self.end {
let value = self.current;
self.current += 1;
Some(value)
} else {
None
}
}
}
fn main() {
let range = Range { start: 0, end: 5 };
for i in range {
println!("Custom range: {}", i);  // 0, 1, 2, 3, 4
}
}

Iterating Over Collections

struct ShoppingCart {
items: Vec<String>,
}
impl ShoppingCart {
fn new() -> Self {
ShoppingCart { items: Vec::new() }
}
fn add_item(&mut self, item: String) {
self.items.push(item);
}
// Immutable iterator
fn iter(&self) -> impl Iterator<Item = &String> {
self.items.iter()
}
// Mutable iterator
fn iter_mut(&mut self) -> impl Iterator<Item = &mut String> {
self.items.iter_mut()
}
}
fn main() {
let mut cart = ShoppingCart::new();
cart.add_item("Apple".to_string());
cart.add_item("Banana".to_string());
cart.add_item("Orange".to_string());
// Immutable iteration
for item in cart.iter() {
println!("Item: {}", item);
}
// Mutable iteration
for item in cart.iter_mut() {
*item = format!("Fresh {}", item);
}
println!("Updated cart:");
for item in cart.iter() {
println!("Item: {}", item);
}
}

9. Parallel Iteration

Using Rayon for Parallel Processing

// Add to Cargo.toml:
// [dependencies]
// rayon = "1.7"
use rayon::prelude::*;
fn main() {
let numbers: Vec<i32> = (0..1000).collect();
// Sequential iteration
let start = std::time::Instant::now();
let squares_seq: Vec<i32> = numbers.iter()
.map(|&x| x * x)
.collect();
println!("Sequential: {:?}", start.elapsed());
// Parallel iteration
let start = std::time::Instant::now();
let squares_par: Vec<i32> = numbers.par_iter()
.map(|&x| x * x)
.collect();
println!("Parallel: {:?}", start.elapsed());
// Parallel with filter
let even_squares: Vec<i32> = numbers.par_iter()
.filter(|&&x| x % 2 == 0)
.map(|&x| x * x)
.collect();
println!("Even squares count: {}", even_squares.len());
// Parallel sum
let sum: i32 = numbers.par_iter().sum();
println!("Parallel sum: {}", sum);
}

10. For Loop Patterns

Common Patterns

fn main() {
// Finding maximum
let numbers = vec![3, 7, 2, 9, 5];
let mut max = numbers[0];
for &num in &numbers {
if num > max {
max = num;
}
}
println!("Max: {}", max);
// Using iterator method
let max = numbers.iter().max().unwrap();
println!("Max using iterator: {}", max);
// Finding element
let target = 7;
let mut found_index = None;
for (i, &num) in numbers.iter().enumerate() {
if num == target {
found_index = Some(i);
break;
}
}
println!("Found at: {:?}", found_index);
// Using iterator position
let found = numbers.iter().position(|&x| x == target);
println!("Found using position: {:?}", found);
// Accumulating
let sum: i32 = numbers.iter().sum();
println!("Sum: {}", sum);
// Building new collection
let doubled: Vec<i32> = numbers.iter().map(|&x| x * 2).collect();
println!("Doubled: {:?}", doubled);
}

Nested Loops Patterns

fn main() {
// Multiplication table
for i in 1..=5 {
for j in 1..=5 {
print!("{:4}", i * j);
}
println!();
}
// Triangle pattern
for i in 1..=5 {
for _ in 0..i {
print!("* ");
}
println!();
}
// 2D array traversal
let matrix = vec![
vec![1, 2, 3],
vec![4, 5, 6],
vec![7, 8, 9],
];
// Sum of all elements
let mut sum = 0;
for row in &matrix {
for &val in row {
sum += val;
}
}
println!("Sum of all elements: {}", sum);
// Diagonal sum
let mut diagonal_sum = 0;
for i in 0..matrix.len() {
diagonal_sum += matrix[i][i];
}
println!("Diagonal sum: {}", diagonal_sum);
}

11. Error Handling in Loops

Continuing on Error

use std::num::ParseIntError;
fn main() {
let inputs = vec!["42", "24", "abc", "12", "xyz"];
let mut valid_numbers = Vec::new();
// Skip invalid inputs
for input in inputs {
match input.parse::<i32>() {
Ok(num) => valid_numbers.push(num),
Err(_) => continue,  // Skip invalid
}
}
println!("Valid numbers: {:?}", valid_numbers);
// Using filter_map (more idiomatic)
let inputs2 = vec!["42", "24", "abc", "12", "xyz"];
let numbers: Vec<i32> = inputs2.iter()
.filter_map(|s| s.parse().ok())
.collect();
println!("Filtered numbers: {:?}", numbers);
// Collect results with errors
let results: Vec<Result<i32, ParseIntError>> = inputs2.iter()
.map(|s| s.parse())
.collect();
println!("Results: {:?}", results);
}

Breaking on Error

use std::fs::File;
use std::io::{self, BufRead};
fn read_lines_until_error() -> io::Result<()> {
let file = File::open("example.txt")?;
let reader = io::BufReader::new(file);
for line in reader.lines() {
match line {
Ok(content) => {
if content.is_empty() {
break;  // Stop at empty line
}
println!("Line: {}", content);
}
Err(e) => return Err(e),  // Propagate error
}
}
Ok(())
}
fn main() {
match read_lines_until_error() {
Ok(()) => println!("File processed successfully"),
Err(e) => println!("Error reading file: {}", e),
}
}

12. Performance Best Practices

Loop Optimizations

fn main() {
// Bad: Repeated length calculation
let data = vec![1, 2, 3, 4, 5];
for i in 0..data.len() {
println!("{}", data[i]);  // Bounds check each iteration
}
// Good: Iterate directly
for &item in &data {
println!("{}", item);  // No bounds checks
}
// Bad: Collecting unnecessarily
let squares: Vec<i32> = data.iter().map(|&x| x * x).collect();
for square in squares {
println!("{}", square);
}
// Good: Chain operations without collecting
for square in data.iter().map(|&x| x * x) {
println!("{}", square);
}
// Bad: Multiple passes
let sum: i32 = data.iter().sum();
let count = data.len();
let avg = sum as f64 / count as f64;
// Good: Single pass (if needed for complex operations)
let mut sum = 0;
let mut count = 0;
for &x in &data {
sum += x;
count += 1;
}
let avg = sum as f64 / count as f64;
}

Memory Layout Considerations

fn main() {
// Struct of arrays vs array of structs
// Bad: Array of structs (poor cache locality for field access)
struct Point {
x: f32,
y: f32,
}
let points: Vec<Point> = (0..1000).map(|i| Point {
x: i as f32,
y: i as f32,
}).collect();
// Accessing all x coordinates causes cache misses
let mut x_sum = 0.0;
for point in &points {
x_sum += point.x;
}
// Good: Struct of arrays (better cache locality)
struct Points {
x: Vec<f32>,
y: Vec<f32>,
}
let points2 = Points {
x: (0..1000).map(|i| i as f32).collect(),
y: (0..1000).map(|i| i as f32).collect(),
};
// All x coordinates are contiguous in memory
let mut x_sum2 = 0.0;
for &x in &points2.x {
x_sum2 += x;
}
}

13. Advanced For Loop Techniques

Infinite Iterators

fn main() {
// Infinite iterator (take to limit)
let mut counter = 0;
for i in std::iter::repeat(5).take(5) {
println!("Repeat: {}", i);
}
// Cycle through finite sequence
let colors = vec!["red", "green", "blue"];
for color in colors.iter().cycle().take(7) {
println!("Cycle: {}", color);
}
// Generate infinite sequence
for i in std::iter::successors(Some(0), |&n| Some(n + 1)).take(5) {
println!("Successor: {}", i);
}
// Fibonacci with successors
let fib = std::iter::successors(Some((0, 1)), |&(a, b)| Some((b, a + b)))
.map(|(a, _)| a)
.take(10)
.collect::<Vec<_>>();
println!("Fibonacci: {:?}", fib);
}

Custom Iterator Combinators

fn main() {
let data = vec![1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
// Windows (sliding window)
for window in data.windows(3) {
println!("Window: {:?}", window);
}
// Chunks
for chunk in data.chunks(3) {
println!("Chunk: {:?}", chunk);
}
// Pairwise (using zip)
for (a, b) in data.iter().zip(data.iter().skip(1)) {
println!("Pair: ({}, {})", a, b);
}
// Group by adjacent
use std::iter::Peekable;
let numbers = vec![1, 1, 2, 2, 2, 3, 4, 4, 5];
let mut iter = numbers.iter().peekable();
while let Some(&first) = iter.next() {
let mut count = 1;
while let Some(&&next) = iter.peek() {
if next == first {
count += 1;
iter.next();
} else {
break;
}
}
println!("{} appears {} times", first, count);
}
}

Conclusion

Rust's for loops and iterators provide powerful, safe, and efficient ways to process sequences of data:

Key Takeaways

1. Iterator-based: For loops work with any type implementing IntoIterator
2. Ownership control: Choose between iter(), iter_mut(), and into_iter()
3. Zero-cost abstractions: Iterators compile to efficient code
4. Expressiveness: Chain combinators for complex transformations
5. Safety: Bounds checking and borrow checker prevent errors
6. Flexibility: Work with ranges, collections, custom types

Common Patterns

Pattern	Description	Example
Basic iteration	for item in collection	for i in 0..10
With index	.enumerate()	for (i, item) in items.iter().enumerate()
Filtering	.filter()	for even in numbers.iter().filter(|&|x % 2 == 0)
Transformation	.map()	for squared in numbers.iter().map(|&x| x * x)
Early exit	break/continue	if condition { break; }
Nested loops	Loop labels	'outer: for ... { break 'outer; }

Best Practices

1. Prefer iterators over indexing when possible
2. Use enumerate() when you need both index and value
3. Chain combinators for readable transformations
4. Consider performance with large datasets
5. Use break and continue judiciously
6. Leverage filter_map() for filtering + transformation
7. Profile parallel iterators for CPU-bound tasks

Performance Guidelines

• Direct iteration is usually fastest
• Avoid unnecessary collect() calls
• Use step_by() for skipping elements
• Consider cache locality for large data structures
• Profile before optimizing

Rust's for loops and iterators provide a powerful, expressive, and safe way to work with sequences of data, making code both readable and efficient.