Introduction

The zip function in Rust is a method provided by the Iterator trait that combines two iterators into a single iterator of pairs. Each pair consists of one element from each of the original iterators, stopping when the shorter of the two iterators is exhausted. This function is useful for parallel iteration over two collections.

Syntax

The basic syntax of the zip function is as follows:

iterator1.zip(iterator2)

Here, iterator1 and iterator2 are any types that implement the Iterator trait. The resulting iterator yields tuples of the form (item1, item2).

Example Usage

Example 1: Zipping Two Vectors

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

Example 2: Zipping with Different Lengths

fn main() {
    let numbers = vec![1, 2];
    let words = vec!["one", "two", "three"];
    let pairs: Vec<(i32, &str)> = numbers.iter().zip(words.iter()).collect();
    println!("{:?}", pairs); // Output: [(1, "one"), (2, "two")]
}

Example 3: Zipping Infinite Iterators

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

Example 4: Modifying Zipped Elements

fn main() {
    let numbers = vec![1, 2, 3];
    let words = vec!["one", "two", "three"];
    let result: Vec<String> = numbers.iter()
                                     .zip(words.iter())
                                     .map(|(&num, &word)| format!("{} is {}", num, word))
                                     .collect();
    println!("{:?}", result); // Output: ["1 is one", "2 is two", "3 is three"]
}

Example 5: Using Zip with Enumerate

fn main() {
    let words = vec!["apple", "banana", "cherry"];
    for (index, (word, &length)) in words.iter().zip(words.iter().map(|word| word.len())).enumerate() {
        println!("Index: {}, Word: {}, Length: {}", index, word, length);
    }
    // Output:
    // Index: 0, Word: apple, Length: 5
    // Index: 1, Word: banana, Length: 6
    // Index: 2, Word: cherry, Length: 6
}

Considerations

• The zip method stops as soon as either of the input iterators is exhausted, which means the resulting iterator will be as long as the shorter of the two input iterators.

See Also

• enumerate - Adds a counter to an iterator, returning an iterator of pairs where the first element is the counter and the second is the item.
• map - Transforms each element of an iterator and returns a new iterator with the transformed elements.
• filter - Creates an iterator that only yields elements that satisfy a predicate.
• collect - Transforms an iterator into a collection such as a vector or hash map.
• chain - Combines two iterators into a single iterator.