Introduction

The collect function in Rust is a versatile and powerful tool that allows you to transform an iterator into a collection such as a vector, a hash map, or other types that implement the FromIterator trait. This function is widely used in Rust programming for its convenience in collecting and processing data efficiently.

Syntax

The basic syntax of the collect function is as follows:

iterator.collect::<CollectionType>()

Here, iterator is any type that implements the Iterator trait, and CollectionType is the type of collection you want to create from the iterator.

Example Usage

Example 1: Collecting into a Vector

fn main() {
    let numbers = vec![1, 2, 3, 4, 5];
    let even_numbers: Vec<i32> = numbers.into_iter().filter(|&x| x % 2 == 0).collect();
    println!("{:?}", even_numbers); // Output: [2, 4]
}

Example 2: Collecting into a HashMap

use std::collections::HashMap;

fn main() {
    let pairs = vec![("one", 1), ("two", 2), ("three", 3)];
    let map: HashMap<&str, i32> = pairs.into_iter().collect();
    println!("{:?}", map); // Output: {"one": 1, "two": 2, "three": 3}
}

Example 3: Collecting into a String

fn main() {
    let chars = vec!['h', 'e', 'l', 'l', 'o'];
    let string: String = chars.into_iter().collect();
    println!("{}", string); // Output: hello
}

Example 4: Collecting into a HashSet

use std::collections::HashSet;

fn main() {
    let numbers = vec![1, 2, 2, 3, 4, 4, 5];
    let unique_numbers: HashSet<i32> = numbers.into_iter().collect();
    println!("{:?}", unique_numbers); // Output: {1, 2, 3, 4, 5}
}

Example 5: Collecting into a Custom Type

use std::collections::BTreeMap;

fn main() {
    let pairs = vec![(1, "one"), (2, "two"), (3, "three")];
    let map: BTreeMap<i32, &str> = pairs.into_iter().collect();
    println!("{:?}", map); // Output: {1: "one", 2: "two", 3: "three"}
}

Considerations

The type to collect into must implement the FromIterator trait.
Type inference can often determine the collection type, but sometimes you might need to specify it explicitly using the turbofish syntax (::).
Using collect can be memory intensive if the collection grows large; consider using iterators for processing large datasets.