Rust Iterators for Beginners | map, filter, fold Explained

Rust Iterators for Beginners | map, filter, fold Explained

Rust iterators provide a powerful and expressive way to process sequences of data efficiently. By mastering methods like iter(), map(), filter(), and fold(), you can transform, filter, and reduce collections with concise and readable code.

Code

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

  // Create an iterator over references to elements
  let mut iter = numbers.iter();
  println!("{:?}", iter.next());  // Some(&1)
  println!("{:?}", iter.next());  // Some(&2)

  // Use map to double each element and collect into a new vector
  let doubled: Vec = numbers
    .iter()
    .map(|x| x * 2)
    .collect();
  println!("Doubled: {:?}", doubled);  // [2, 4, 6, 8, 10]

  // Use filter to keep only even numbers
  let evens: Vec = numbers
    .iter()
    .filter(|&x| x % 2 == 0)
    .cloned()  // convert &i32 to i32
    .collect();
  println!("Evens: {:?}", evens);  // [2, 4]

  // Use fold to sum all elements
  let sum = numbers.iter().fold(0, |acc, &x| acc + x);
  println!("Sum: {}", sum);  // 15

  // Enumerate elements with their indices
  for (index, value) in numbers.iter().enumerate() {
    println!("Index {}: {}", index, value);
  }

  // Take first 3 elements
  let first_three: Vec<_> = numbers.iter().take(3).cloned().collect();
  println!("First three: {:?}", first_three);  // [1, 2, 3]

  // Skip first 2 elements
  let after_two: Vec<_> = numbers.iter().skip(2).cloned().collect();
  println!("After skipping two: {:?}", after_two);  // [3, 4, 5]
}

Key Points

• Use iter() to create an iterator over references to collection elements.
• map() transforms each element by applying a function, producing a new iterator.
• filter() keeps only elements that satisfy a predicate, allowing selective processing.
• fold() reduces an iterator to a single value by accumulating results with a closure.
• Methods like enumerate(), take(), and skip() provide fine-grained control over iteration.