What Is the Difference Between Lazy and Eager Evaluation in Rust Iterators?

Lazy evaluation means Rust iterators do nothing until you call a consuming method, while eager evaluation executes code immediately upon definition.

// Lazy: Does not print until collect() is called
let numbers = vec![1, 2, 3];
let doubled = numbers.iter().map(|x| {
    println!("Processing {}", x);
    x * 2
});

// Eager: Prints immediately when the loop starts
for n in numbers.iter().map(|x| {
    println!("Processing {}", x);
    x * 2
}) {
    println!("Got: {}", n);
}

// Force lazy evaluation to run
let result: Vec<_> = doubled.collect();

Rust iterators are lazy by default to allow chaining operations without intermediate allocations. You must call a consuming method like collect(), for_each(), or sum() to trigger the actual computation.

Lazy evaluation is like writing a recipe but not cooking until you actually need the meal, whereas eager evaluation is cooking the meal the moment you write the recipe. Rust uses lazy evaluation for iterators to save memory and time by only doing work when you explicitly ask for the results. This matters because it lets you chain many operations together efficiently without creating temporary data for every single step.