Processing a Series of Items with Iterators

In Rust, iterators provide a powerful and idiomatic way to process sequences of items. They are a core concept for performing transformations, filtering, and aggregations on collections or any type that can yield a sequence of values, often in a highly efficient and concise manner.

What are Iterators?
At its heart, an iterator is an object that implements the `Iterator` trait. The most fundamental method of this trait is `next()`, which returns an `Option<Self::Item>`. When there's another item in the sequence, `next()` returns `Some(item)`; otherwise, it returns `None`, signaling the end of the iteration.

Why Use Iterators?
1. Efficiency and Laziness: Rust iterators are inherently *lazy*. This means that transformations like `map` or `filter` don't actually perform any work or allocate new memory until a *consuming* method (e.g., `sum()`, `collect()`, `for_each()`, or `next()`) is called. This allows for highly optimized processing pipelines where only the necessary computations are performed.
2. Conciseness and Readability: Iterators promote a functional programming style, enabling complex data manipulations to be expressed clearly and compactly through method chaining.
3. Composability: You can chain multiple iterator adapters together (e.g., `filter().map().sum()`), creating sophisticated data processing logic without creating intermediate collections.
4. Abstraction: They abstract over the underlying data structure, allowing you to use the same processing logic whether you're iterating over a `Vec`, a `HashMap`, a range, or a custom sequence.

Key Traits:
* `Iterator` Trait: Defines the core behavior for an iterator, primarily through the `next()` method.
* `IntoIterator` Trait: This trait allows a type to be converted *into* an iterator. Many collection types (like `Vec<T>`, `String`, `HashMap<K, V>`) implement `IntoIterator`, which is why you can use them directly in `for` loops or with methods that expect an iterator (e.g., `vec.into_iter()`, `vec.iter()`, `vec.iter_mut()`).
* `iter()`: Borrows each item by reference (`&T`).
* `iter_mut()`: Borrows each item by mutable reference (`&mut T`).
* `into_iter()`: Takes ownership of the collection and yields owned items (`T`).

Common Iterator Adapters and Consuming Methods:
* Adapters (create new iterators):
* `map(|x| ...)`: Transforms each item into a new item.
* `filter(|x| ...)`: Keeps only items for which the closure returns `true`.
* `enumerate()`: Yields pairs `(index, item)`.
* `skip(n)`: Skips the first `n` items.
* `take(n)`: Takes only the first `n` items.
* `peekable()`: Allows looking at the next item without consuming it.
* Consuming Methods (process items and often return a single result):
* `collect()`: Gathers all items into a new collection (e.g., `Vec`, `HashMap`, `String`). Requires type inference or the turbofish syntax (`::<>`).
* `for_each(|x| ...)`: Consumes the iterator by applying a closure to each item for side effects.
* `sum()` / `product()`: Computes the sum or product of numeric items.
* `fold(initial_value, |accumulator, item| ...)`: Reduces the iterator to a single value by repeatedly applying a closure.
* `count()`: Returns the number of items in the iterator.
* `max()` / `min()`: Returns the maximum or minimum item.
* `find(|x| ...)`: Returns the first item that satisfies the predicate.

Creating Iterators:
* From collections: `my_vec.iter()`, `my_vec.iter_mut()`, `my_vec.into_iter()`.
* From ranges: `0..10` (exclusive end), `0..=10` (inclusive end).
* From `std::iter` functions: `std::iter::once()`, `std::iter::empty()`, `std::iter::repeat()`, `std::iter::successors()`.
* By implementing the `Iterator` trait for your custom types.

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

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

    // Example 1: Filter even numbers and sum their squares
    // .iter() creates an iterator yielding immutable references (&i32)
    let sum_of_even_squares: u32 = numbers
        .iter()
        .filter(|&&x| x % 2 == 0) // Filter for even numbers. '&&x' dereferences from &&i32 to i32
        .map(|&x| (x * x) as u32) // Map each even number to its square. '&x' dereferences from &i32 to i32
        .sum(); // Consume the iterator by summing the results (requires elements to be u32)

    println!("Sum of squares of even numbers: {}", sum_of_even_squares);
    // Expected: (2*2) + (4*4) + (6*6) + (8*8) + (10*10) = 4 + 16 + 36 + 64 + 100 = 220

    // Example 2: Collect odd numbers doubled into a new vector
    let doubled_odd_numbers: Vec<i32> = numbers
        .iter() // Get an iterator over references
        .filter(|&&x| x % 2 != 0) // Filter for odd numbers
        .map(|&x| x * 2) // Double each odd number
        .collect(); // Consume and collect the results into a new Vec<i32>

    println!("Doubled odd numbers: {:?}", doubled_odd_numbers);
    // Expected: [2, 6, 10, 14, 18]

    // Example 3: Using into_iter() to consume the original vector and transform items
    // into_iter() takes ownership of the vector and its elements.
    let original_numbers_for_modification = vec![10, 20, 30];
    let incremented_numbers: Vec<i32> = original_numbers_for_modification
        .into_iter() // Get an iterator that yields owned items (i32)
        .map(|x| x + 1) // Increment each number
        .collect();

    println!("Incremented numbers (from into_iter): {:?}", incremented_numbers);
    // Expected: [11, 21, 31]
    // The `original_numbers_for_modification` vector can no longer be used here
    // uncommenting the line below would result in a compile-time error:
    // println!("{:?}", original_numbers_for_modification);

    // Example 4: Processing a range and using for_each for side effects
    println!("\nCounting up to 5:");
    (1..=5) // Create an inclusive range iterator
        .for_each(|n| println!("  Number: {}", n)); // Consume by printing each item

    // Example 5: Chaining multiple adapters and a consuming method
    let sentence = "hello rust iterators are awesome";
    let capitalized_words: Vec<String> = sentence
        .split_whitespace() // Iterator over &str slices of words
        .map(|word| {
            let mut chars = word.chars();
            match chars.next() {
                None => String::new(),
                Some(first_char) => first_char.to_uppercase().collect::<String>() + chars.as_str(),
            }
        })
        .collect();
    println!("\nCapitalized words: {:?}", capitalized_words);
    // Expected: ["Hello", "Rust", "Iterators", "Are", "Awesome"]
}
```