Introduction

The chain function in Rust is an iterator adapter that allows you to combine two iterators into a single continuous sequence. This function is useful when you need to process elements from two different sources as if they were a single iterator.

Syntax


iterator1.chain(iterator2)

The chain function takes another iterator as an argument and returns a new iterator that yields all items from the first iterator followed by all items from the second iterator.

Example Usage

Example 1: Chaining Two Vectors

fn main() {
    let vec1 = vec![1, 2, 3];
    let vec2 = vec![4, 5, 6];
    let result: Vec<i32> = vec1.into_iter().chain(vec2.into_iter()).collect();
    println!("{:?}", result); // Output: [1, 2, 3, 4, 5, 6]
}

Example 2: Chaining a Vector and a Range

fn main() {
    let vec = vec![1, 2, 3];
    let range = 4..7;
    let result: Vec<i32> = vec.into_iter().chain(range).collect();
    println!("{:?}", result); // Output: [1, 2, 3, 4, 5, 6]
}

Example 3: Chaining Two Different Types of Iterators

fn main() {
    let vec = vec![1, 2, 3];
    let array = [4, 5, 6];
    let result: Vec<i32> = vec.into_iter().chain(array.into_iter()).collect();
    println!("{:?}", result); // Output: [1, 2, 3, 4, 5, 6]
}

Example 4: Chaining Filtered Iterators

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

Example 5: Chaining with Empty Iterators

fn main() {
    let vec1: Vec<i32> = vec![];
    let vec2 = vec![1, 2, 3];
    let result: Vec<i32> = vec1.into_iter().chain(vec2.into_iter()).collect();
    println!("{:?}", result); // Output: [1, 2, 3]
}

Considerations

Chained iterators are consumed in the order they are provided, with the first iterator being completely exhausted before the second iterator is started.
Both iterators must yield elements of the same type, as the resulting iterator will have the same type.