# Mastering Iterators: Comprehensive Insights You Need **Iterators** are a fundamental concept in programming that enable you to process a sequence of items, such as elements in a collection, one at a time, without revealing the collection's internal structure. They form the backbone of operations like looping, filtering, and mapping over collections. When you encounter constructs like these, you can liken them to functional or stream-based idioms found in languages such as C# or Java. When you see something like: ```rust collection.iter() .map(...) .filter(...) .take(...) .collect(); ``` **Why Iterators Are Useful** * **Abstraction**: They hide the underlying container’s implementation. You don’t need to know if it’s an array, a linked list, or some more specialized structure. * **Safety / Encapsulation**: With an iterator, you typically avoid directly indexing into a collection’s memory. This reduces off-by-one errors, out-of-bounds errors, or concurrency issues. * **Composability**: Iterators can be transformed, filtered, and combined to express complex operations in a clean, functional style. # Iterators in Rust Rust’s iterator system is powerful and versatile, offering developers a robust toolset for managing collections efficiently. It simplifies the code and reduces the potential for errors. This not only makes the code more readable but also aligns with functional programming paradigms, making it easier for developers familiar with languages like C# or Java to adapt. 1. **They Are Lazy** * In Rust, when you call methods like `.map()`, `.filter()`, or `.take()` on an iterator, it does not immediately create a new collection. Instead, these methods return a *new iterator* that, when advanced, processes items on demand. * This means you can build up chained iterator calls without incurring overhead until you actually consume the iterator (e.g., in a for loop, or when calling a terminal method like `.collect()`). 2. **Three Main “Iterator” Traits** * `Iterator`: The trait for iterators that produce items by value. Typically you implement this when you want to define how to produce a sequence of items. * `IntoIterator`: For types (like `Vec`, slices, and so on) that can be converted into an iterator. * `DoubleEndedIterator`: An extension that allows “reverse” iteration (calling `.next_back()` in addition to `.next()` from the front). 3. **Ownership, Borrowing, and Lifetimes** * Rust’s type system enforces rules to ensure safety. For iterators, this means that when you iterate over a collection, either you move (take ownership of) the collection or you borrow from it in a well-defined way. * `iter()` borrows each element by reference. * `into_iter()` consumes (takes ownership of) the elements, so the iterator yields the items by value. * `iter_mut()` borrows each element mutably, allowing you to modify items in place. 4. **Common Methods** * `map(f)`: Apply a function `f` to each item. * `filter(pred)`: Keep only items where `pred(item)` is `true`. * `fold(init, f)`: Accumulate items into a single value, starting from `init`, applying `f` in a fold/reduction manner. * `collect()`: Consume an iterator and gather the items into a collection (like a `Vec`, `HashSet`, etc.). * `take(n)`, `skip(n)`, `enumerate()`, etc.: Additional combinators for slicing, offset, or enumerating. 5. **Consuming vs. Adapting Iterators** In Rust’s library documentation, you might see a distinction between “consuming” vs. “adapting” iterators: * **Consuming**: These methods take ownership of the iterator to produce a final value or another data structure (e.g., `collect()`, `fold()`). Once consumed, the iterator cannot be used again. * **Adapting**: These methods produce a *new* iterator (e.g., `map`, `filter`). These can be chained before any final consumption. ## **Examples** Below is some "cookbook"-style collection of **common and practical iterator patterns** in Rust. This will help you become more comfortable and familiar with iterators, allowing you to later explore them in greater depth. ### 1\. **Iterate and Collect into a New Vector** A basic example: transform and collect. ```rust fn example_collect() { let numbers = vec![1, 2, 3, 4, 5]; // Double each number and collect into a new Vec let doubled: Vec = numbers.iter().map(|x| x * 2).collect(); println!("{:?}", doubled); // Output: [2, 4, 6, 8, 10] } ``` `iter()` borrows each element (so `x` is `&i32`). `map(|x| x * 2)` applies a function to each element. `|x| x * 2` is closure. `collect()` finalizes the lazy chain, producing the `Vec`. --- ### 2\. **Filter Items Based on a Condition** Use `filter` to keep only items meeting a criterion. ```rust fn example_filter() { let numbers = vec![10, 15, 20, 25, 30]; // Keep only multiples of 10 let multiples_of_ten: Vec = numbers .into_iter() // Now x is i32, not &i32 .filter(|x| x % 10 == 0) .collect(); println!("{:?}", multiples_of_ten); // Output: [10, 20, 30] } ``` `into_iter()` consumes `numbers` and yields `i32` (by value). `filter(...)` returns a new iterator keeping only those items where the predicate is true. --- ### 3\. **Filter and Map in One Step:** `filter_map` Sometimes you want to transform items and discard certain items altogether. `filter_map` combines `filter` and `map` in one step, working with `Option`. ```rust let inputs = vec!["42", "93", "hello", "128", "xyz"]; // Try parsing each string as an integer. // If successful, keep the integer; otherwise, skip. let parsed: Vec = inputs .iter() .filter_map(|s| s.parse::().ok()) .collect(); // parsed: [42, 93, 128] ``` `s.parse::().ok()` returns `Some(i32)` if parse succeeded, or `None` otherwise. `filter_map` only yields `Some` items. --- ### 4\. **Combine Multiple Iterators:** `chain` Use `chain` to create a single iterator that yields items from two or more sources sequentially. ```rust let nums1 = vec![1, 2, 3]; let nums2 = vec![4, 5, 6]; let chained: Vec = nums1 .into_iter() .chain(nums2.into_iter()) .collect(); // chained: [1, 2, 3, 4, 5, 6] ``` `chain` takes two iterators and iterates over the first fully, then the second. In this example, `nums1` and `nums2` are both consumed (moved) by `into_iter()`. --- ### 5\. **Enumerate Items with** `enumerate` Sometimes you need both the index and the value. ```rust let animals = vec!["cat", "dog", "bird"]; for (index, animal) in animals.iter().enumerate() { println!("{}: {}", index, animal); } // Output: // 0: cat // 1: dog // 2: bird ``` `enumerate()` yields `(index, item)` pairs. The `index` starts at 0 by default. --- ### 6\. **Find the First Matching Item:** `find` The `find` method returns the first item that satisfies a condition (as an `Option`). ```rust let numbers = vec![1, 3, 5, 7, 9]; // Find the first number that is divisible by 3 if let Some(found) = numbers.iter().find(|&&x| x % 3 == 0) { println!("Found: {}", found); // Output: Found: 3 } else { println!("No match found"); } ``` `find` stops searching after the first match. Returns `None` if no match is found. --- ### 7\. **Take While a Condition is True:** `take_while` Use `take_while` to yield items only as long as a predicate holds. (Note: This is available via `Iterator::take_while` in stable Rust 1.52+.) ```rust let numbers = vec![2, 4, 6, 8, 10, 1, 12]; // Take only even numbers until we reach the first odd let evens_up_to_odd: Vec = numbers .into_iter() .take_while(|x| x % 2 == 0) .collect(); println!("{:?}", evens_up_to_odd); // Output: [2, 4, 6, 8, 10] ``` Once `take_while` sees a value that doesn’t satisfy the predicate, it stops altogether. --- ### 8\. **Accumulating/Reducing:** `fold` Use `fold` to accumulate values into a single result. This is often used for sums, products, or more advanced aggregations. ```rust fn example_fold() { let numbers = vec![1, 2, 3, 4, 5]; let sum = numbers.iter().fold(0, |acc, &x| acc + x); println!("Sum is {}", sum); // Output: 15 let product = numbers.iter().fold(1, |acc, &x| acc * x); println!("Product is {}", product); // Output: 120 } ``` The first argument to `fold` is the initial accumulator value. The closure receives the accumulator and the next item. --- ### 9\. **Partition Items into Two Groups:** `partition` `partition` splits items into two collections based on a condition, returning `(Vec, Vec)`. ```rust fn example_partition() { let numbers = vec![1, 2, 3, 4, 5, 6]; let (even, odd): (Vec, Vec) = numbers .into_iter() .partition(|x| x % 2 == 0); println!("Even: {:?}", even); // Even: [2, 4, 6] println!("Odd: {:?}", odd); // Odd: [1, 3, 5] } ``` The first `Vec` collects items where the predicate is true, and the second collects items where it is false. --- ### 10\. **Zip Two Iterators Together:** `zip` `zip` pairs items from two iterators into `(item1, item2)` tuples. ```rust fn example_zip() { let letters = vec!['a', 'b', 'c']; let numbers = vec![1, 2, 3, 4]; // Zip together into pairs let zipped: Vec<(char, i32)> = letters.into_iter().zip(numbers).collect(); println!("{:?}", zipped); // Output: [('a', 1), ('b', 2), ('c', 3)] } ``` The iteration stops when the shortest iterator ends. In this example, `letters` has 3 items, `numbers` has 4, so only 3 pairs are created. --- ### 11\. **Flatten an Iterator of Iterators:** `flatten` If you have nested iterators (e.g., a `Vec>`), you can flatten it into a single sequence. ```rust fn example_flatten() { let nested = vec![vec![1, 2], vec![3, 4, 5], vec![6]]; let flattened: Vec = nested.into_iter().flatten().collect(); println!("{:?}", flattened); // Output: [1, 2, 3, 4, 5, 6] } ``` `flatten` automatically iterates through each sub-iterator/item. You can also use `flat_map` if you need to transform and flatten in one step. --- ### 12\. **Skipping Elements or Taking a Specific Count:** `skip` / `take` Use `skip` to ignore a certain number of items, `take` to limit iteration to a certain count. ```rust fn example_skip_take() { let numbers = vec![10, 20, 30, 40, 50, 60]; // Skip the first 2, then take the next 3 let slice: Vec = numbers .iter() .skip(2) .take(3) .copied() // because we had .iter() -> &i32 .collect(); println!("{:?}", slice); // Output: [30, 40, 50] } ``` `skip(n)` ignores the first `n` items. `take(n)` yields only the next `n` items, then stops. `.copied()` turns `&i32` into `i32`; you could also use `.cloned()` or just leave them as references if that’s acceptable. # IntoIterator Trait `IntoIterator` is a trait that defines how a type can be converted into an iterator. It's one of the fundamental traits in Rust's collections and iteration system. ```rust pub trait IntoIterator { type Item; type IntoIter: Iterator; fn into_iter(self) -> Self::IntoIter; } ``` This trait has three key components: * `Item`: The type of item that the iterator will produce * `IntoIter`: The specific iterator type that will be returned * `into_iter()`: The method that consumes the collection and returns an iterator. ## How IntoIterator Is Used **For loops**: When you write a `for` loop in Rust, the compiler automatically calls into\_iter() on the collection you're iterating over: ```rust for element in collection { // This is actually doing: for element in collection.into_iter() { ... } } ``` When you write a `for` loop or manually call `collection.into_iter()`, Rust decides **which implementation** to call based on whether you’re iterating over the collection by value (`collection.into_iter()`), by reference (`(&collection).into_iter()`), or by mutable reference (`(&mut collection).into_iter()`). **Converting collections to iterators**: You can explicitly call into\_iter() to convert a collection into an iterator: ```rust let vec = vec![1, 2, 3]; let iter = vec.into_iter(); // Consumes vec, returns an iterator ``` ## Different Implementations Most collections in Rust implement `IntoIterator` in multiple ways: **For the collection itself (by value)**: Consumes the collection, returning an iterator that takes ownership of the elements: ```rust impl IntoIterator for Vec { type Item = T; type IntoIter = std::vec::IntoIter; fn into_iter(self) -> Self::IntoIter { /* ... */ } } ``` **For references to the collection (&)**: Creates an iterator that borrows the elements: ```rust impl<'a, T> IntoIterator for &'a Vec { type Item = &'a T; type IntoIter = std::slice::Iter<'a, T>; fn into_iter(self) -> Self::IntoIter { /* ... */ } } ``` **For mutable references (&mut)**: Creates an iterator that mutably borrows the elements: ```rust impl<'a, T> IntoIterator for &'a mut Vec { type Item = &'a mut T; type IntoIter = std::slice::IterMut<'a, T>; fn into_iter(self) -> Self::IntoIter { /* ... */ } } ``` `std::slice::Iter<'a, T>` , `std::slice::IterMut<'a, T>` and `std::vec::IntoIter` are **different iterator types** you're seeing in Rust. Each one corresponds to a different **way of iterating** over a collection, based on ownership and mutability. ## Understanding into\_iter() and Ownership The `into_iter()` method can handle different ownership patterns, making Rust's iteration system super flexible. Let's discuss how it works with values, references, and mutable references, and how `iter()` fits into this system. **How into\_iter() works with different ownership types** The `into_iter()` method behaves differently depending on whether you call it on: 1. **Value (T)**: Consumes the collection, taking ownership 2. **Reference (&T)**: Borrows the collection immutably 3. **Mutable reference (&mut T)**: Borrows the collection mutably This is achieved through separate implementations of the `IntoIterator` trait for each case. ```rust // For Vec as an example: // Takes ownership (consumes the Vec) impl IntoIterator for Vec { type Item = T; // Iterator yields owned values // ... } // Borrows immutably impl<'a, T> IntoIterator for &'a Vec { type Item = &'a T; // Iterator yields references // ... } // Borrows mutably impl<'a, T> IntoIterator for &'a mut Vec { type Item = &'a mut T; // Iterator yields mutable references // ... } ``` **Examples:** ```rust let v = vec![1, 2, 3]; // Takes ownership - consumes v let iter1 = v.into_iter(); // Iterator yields values (T) // v is no longer usable here let v = vec![1, 2, 3]; // Borrows immutably let iter2 = (&v).into_iter(); // Iterator yields references (&T) // v is still usable here // Borrows mutably let mut v = vec![1, 2, 3]; let iter3 = (&mut v).into_iter(); // Iterator yields mutable references (&mut T) // v is still usable after iter3 is dropped // Standard collection methods let v = vec![1, 2, 3]; let iter_a = v.iter(); // Always yields &T let iter_b = v.iter_mut(); // Always yields &mut T let iter_c = v.into_iter(); // Consumes v, yields T ``` The flexibility of `into_iter()` is why `for` loops in Rust work with all three ownership models. The compiler automatically chooses the appropriate implementation based on how you use the collection in the loop. # Iterator Trait The `Iterator` trait provides a way to process sequences of items one at a time, and it serves as the foundation for many functional programming patterns. `Iterator` and `IntoIterator` are two related but different traits that help in working with collections and iterators. `Iterator` is used when you **already have** an iterator and want to iterate over it. The `next()` method is used to fetch elements one by one. Example: ```rust let numbers = vec![1, 2, 3]; let mut iter = numbers.iter(); // Create an iterator over `numbers` println!("{:?}", iter.next()); // Some(1) println!("{:?}", iter.next()); // Some(2) println!("{:?}", iter.next()); // Some(3) println!("{:?}", iter.next()); // None (end of iteration) ``` `numbers.iter()` creates an iterator and calling `next()` moves through the elements. ## Basic Structure ```rust trait Iterator { type Item; fn next(&mut self) -> Option; // Many default methods omitted... } ``` The trait has only one required method to implement: `next()`. Everything else is built on top of this foundation. ## Core Components 1. **Associated Type** `Item`: Defines what type of elements the iterator will produce. 2. `next()` Method: The heart of the iterator pattern. * Returns `Some(item)` if there's another item in the sequence * Returns `None` when iteration is complete * Takes `&mut self` because advancing the iterator changes its internal state ## Implementing Iterator Here's a simple example of implementing the `Iterator` trait: ```rust struct Fibonacci { curr: u32, next: u32, } impl Iterator for Fibonacci { type Item = u32; fn next(&mut self) -> Option { let current = self.curr; self.curr = self.next; self.next = current + self.next; Some(current) } } // Create an iterator that generates the Fibonacci sequence fn fibonacci() -> Fibonacci { Fibonacci { curr: 0, next: 1 } } let fib = fibonacci(); let first_10: Vec = fib.take(10).collect(); ``` ## Relationship to IntoIterator `Iterator` defines how to iterate through a sequence. `IntoIterator` defines how to create an iterator from a value. These two work hand in hand to make a full iteration system. The `IntoIterator::into_iter()` method creates an `Iterator`, and when you use a `for` loop, it automatically uses `IntoIterator` behind the scenes. This design allows for flexibility and powerful abstractions across Rust's standard library and ecosystem. The combination of these traits enables many of Rust's most elegant patterns for working with collections and sequences. ### The iter() Method vs. into\_iter() The `iter()` method is **not** syntactic sugar for `&collection.into_iter()`, but they're closely related. `iter()` is a method implemented specifically for collections in the standard library, while `into_iter()` comes from the `IntoIterator` trait. They serve similar purposes but work differently: ```rust let v = vec![1, 2, 3]; // These two are equivalent: let iter1 = v.iter(); let iter2 = (&v).into_iter(); // Both produce iterators over &T (references) ``` ### **Important Distinctions:** * `iter()` is a method found directly on collection types like Vec and HashMap, while `into_iter()` comes from the `IntoIterator` trait. * `iter()` always borrows the collection and never consumes it, whereas `into_iter()` might consume the collection, depending on whether it's called on a value or a reference. * `iter()` always gives you an iterator over references, while `into_iter()` behaves differently based on how you use it. And `iter_mut()` always provides an iterator over mutable references. # Full Example Below is a detailed example of a custom `Portfolio` struct, which contains a `Vec`. This example includes **three** distinct implementations of the `IntoIterator` trait, each designed to allow different types of iteration over the `Portfolio`: 1. **Consuming iteration**: This type of iteration occurs by value, meaning it takes ownership of the elements. It yields owned `String` values, effectively consuming the `Portfolio` as it iterates through its elements. This is useful when you need to take ownership of the data for further processing or transformation. 2. **Shared iteration**: This iteration happens by shared reference, which means it does not take ownership of the elements. Instead, it yields `&String`, allowing you to read the data without modifying it. This is ideal for scenarios where you need to access the data without altering the original `Portfolio`. 3. **Mutable iteration**: This iteration is performed by mutable reference, yielding `&mut String`. It lets you change the elements of the `Portfolio` as you go through them. This is especially useful when you need to update or transform the data right where it is. For each of these iteration types, we'll show how they work with a custom iterator type: `PortfolioIntoIter`, `PortfolioIter`, and `PortfolioIterMut`. Each of these custom iterator types implements the `Iterator` trait, giving you the tools you need to go through the `Portfolio` in the way you want. This setup not only highlights the flexibility of Rust's iteration patterns but also shows how you can create custom iterators to fit your specific needs. ```rust #[derive(Debug)] struct Portfolio { instruments: Vec, } // An iterator for consuming `Portfolio` (yields owned `String`) struct PortfolioIntoIter { inner: std::vec::IntoIter, } // An iterator for `&Portfolio` (yields `&String`) struct PortfolioIter<'a> { inner: std::slice::Iter<'a, String>, } // An iterator for `&mut Portfolio` (yields `&mut String`) struct PortfolioIterMut<'a> { inner: std::slice::IterMut<'a, String>, } // Constructor for convenience impl Portfolio { fn new(instruments: Vec) -> Self { Portfolio { instruments } } } ``` Now, let's delve into implementing the three distinct variants of the `IntoIterator` trait for our custom iterator types. ```rust // 1) By value (Portfolio -> owned iteration) impl IntoIterator for Portfolio { type Item = String; type IntoIter = PortfolioIntoIter; fn into_iter(self) -> Self::IntoIter { PortfolioIntoIter { // Move out the vector’s own iterator inner: self.instruments.into_iter(), } } } // 2) By shared reference (&Portfolio -> shared iteration) impl<'a> IntoIterator for &'a Portfolio { type Item = &'a String; type IntoIter = PortfolioIter<'a>; fn into_iter(self) -> Self::IntoIter { PortfolioIter { // Borrow the underlying vector’s iterator inner: self.instruments.iter(), } } } // 3) By mutable reference (&mut Portfolio -> mutable iteration) impl<'a> IntoIterator for &'a mut Portfolio { type Item = &'a mut String; type IntoIter = PortfolioIterMut<'a>; fn into_iter(self) -> Self::IntoIter { PortfolioIterMut { // Borrow the underlying vector’s mutable iterator inner: self.instruments.iter_mut(), } } } ``` Now, let's proceed to implement the `Iterator` trait for each of our custom iterator types. This step is crucial because it defines how each iterator will behave when traversing through the elements of the `Portfolio`. By implementing the `Iterator` trait, we specifically implement `next()` for different iterators to advance the iterator and yield the value. ```rust impl Iterator for PortfolioIntoIter { type Item = String; fn next(&mut self) -> Option { self.inner.next() } } impl<'a> Iterator for PortfolioIter<'a> { type Item = &'a String; fn next(&mut self) -> Option { self.inner.next() } } impl<'a> Iterator for PortfolioIterMut<'a> { type Item = &'a mut String; fn next(&mut self) -> Option { self.inner.next() } } ``` Example usage in main() where we create a `Portfolio` instance and iterate over its elements using the different iterator implementations we have defined above. ```rust fn main() { // 1) By value: move the Portfolio and get owned Strings let portfolio = Portfolio::new(vec!["AAPL".into(), "GOOG".into(), "MSFT".into()]); println!("Iterate by value:"); for instrument in portfolio.into_iter() { // instrument is String (owned) println!("{}", instrument); } // `portfolio` is consumed here—can't use it again. // 2) By shared reference: get &String let portfolio_ref = Portfolio::new(vec!["TSLA".into(), "AMZN".into(), "META".into()]); println!("\nIterate by shared reference:"); for instrument in &portfolio_ref { // instrument is &String println!("{}", instrument); } // `portfolio_ref` is still usable (not consumed). // 3) By mutable reference: get &mut String let mut portfolio_mut = Portfolio::new(vec!["NFLX".into(), "DIS".into()]); println!("\nIterate by mutable reference:"); for instrument in &mut portfolio_mut { // instrument is &mut String instrument.push_str(" (edited)"); } println!("{:?}", portfolio_mut); } ``` **Output** ![](https://cdn.hashnode.com/res/hashnode/image/upload/v1742691832840/6a2867fe-6932-45dc-aed0-83d83207bd15.png align="center") With this setup, the same `.into_iter()` method name can produce **three different iterator types** depending on the context of how you call it (owned, immutable reference, or mutable reference)—exactly like `Vec` does in the standard library. # Iterators Without Boilerplate: successors Instead of writing a custom iterator, you can define your sequence generation logic inline with just a closure using successors. `successors` is a **function** in the Rust standard library (`std::iter`) that creates an **iterator** from an initial value and a “successor function.” Formally: ```rust pub fn successors(first: Option, succ: F) -> Successors where F: FnMut(&T) -> Option, ``` `first` is an `Option` – your **starting point** (may or may not exist) and `succ` is a closure or function that, given a reference to the **most recently yielded value**, returns the **next** value as an `Option`. The iterator produced will: * Yield the `first` value **if** it’s `Some(...)`. * Then repeatedly call `succ` on the last yielded value to get the next. * Stop once `succ` returns `None`. This means you can **generate a sequence** on-the-fly **without** building your own `struct` and implementing `Iterator` manually. If you like chaining and pipelining, `successors` fits right in. You can follow it with methods like `.map(...)`, `.filter(...)`, etc., and then `.take(...)` or `.collect()` as needed. Here’s a simple example that starts from `Some(1)` and then keeps adding 1 until we decide to stop at a certain condition. ```rust use std::iter::successors; fn main() { let mut iter = successors(Some(1), |&prev| { let next = prev + 1; if next <= 5 { Some(next) } else { None } }); // Collect into a vector let values: Vec = iter.collect(); println!("{:?}", values); // [1, 2, 3, 4, 5] } ``` We pass `Some(1)` as the first value, so `1` is yielded immediately when iteration begins. For each subsequent item, we apply the closure `|&prev| { ... }`. The iterator yields `1, 2, 3, 4, 5`, then stops. We can implement our previous example **Fibonacci sequence** using `std::iter::successors` as well. Here’s the equivalent version of `Fibonacci` iterator using `successor`. ```rust use std::iter; fn fibonacci() -> impl Iterator { iter::successors(Some((0, 1)), |&(curr, next)| { Some((next, curr + next)) }) .map(|(curr, _)| curr) } fn main() { let first_10: Vec = fibonacci().take(10).collect(); println!("{:?}", first_10); // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34] } ``` **Overall Easier Setup**: `successors(Some(start), |&prev| Some(next))` is all you need to define a sequence and it is more functional-style code. # Conclusion Iterators are a fundamental concept in programming that provide a powerful and flexible way to traverse and manipulate collections. By abstracting the underlying data structure, iterators offer a safe and efficient means to perform operations like mapping, filtering, and reducing. In Rust, the iterator system is particularly robust, supporting lazy evaluation, ownership, borrowing, and a wide range of combinators that enhance code readability and maintainability. Understanding the different traits and methods associated with iterators, such as `Iterator` and `IntoIterator`, allows you to write more expressive and efficient code.