Skip, take

In Rust we can use the skip and take functions to advance to a position in an iterator. The clippy tool recommends skip and take.

With these functions, we narrow down the range of an iter(). We usually need to call iter() first to use skip and take. These functions affect loop performance.

Skip example

To begin, we create an array of 4 numbers. We get an iterator from the array by calling iter() in the for-loop. We print out the values looped over.

fn main() {
    // Source array.
    let values = [10, 20, 30, 40];

    // Loop starting past the first 2 items.
    for value in values.iter().skip(2) {
        println!("SKIP 2 FROM {:?} = {}", values, value);
    }
}
SKIP 2 FROM [10, 20, 30, 40] = 30
SKIP 2 FROM [10, 20, 30, 40] = 40

Take

With take() we iterate over the first elements of a collection like an array. We specify the number of elements we wish to loop over.

fn main() {
    let numbers = [5, 10, 20, 40];
    // Loop over first 2 numbers.
    for number in numbers.iter().take(2) {
        println!("TAKE 2: {number}");
    }
    // Combine skip and take.
    for number in numbers.iter().skip(1).take(2) {
        println!("SKIP 1 TAKE 2: {number}");
    }
}
TAKE 2: 5
TAKE 2: 10
SKIP 1 TAKE 2: 10
SKIP 1 TAKE 2: 20

Skip benchmark

The clippy tool recommends using skip and take instead of for-range loops. But does this improve performance? We test skip and take performance here.

use std::time::*;

fn main() {
    if let Ok(max) = "20000".parse() {
        if let Ok(offset) = "20".parse::<usize>() {
            let top_offset = max - offset;
            // Sample vector.
            let mut source = vec![];
            for _ in 0..max {
                source.push(0);
            }
            source[5000] = 1;

            let mut sum1 = 0;
            let mut sum2 = 0;

            // Version 1: range loop.
            let t0 = Instant::now();
            for _ in 0..max {
                for i in offset..top_offset {
                    if source[i] == 1 {
                        sum1 += 1;
                    }
                }
            }
            println!("{}", t0.elapsed().as_millis());
            // Version 2: take and skip.
            let t1 = Instant::now();
            for _ in 0..max {
                for element in source.iter().take(top_offset).skip(offset) {
                    if *element == 1 {
                        sum2 += 1;
                    }
                }
            }
            println!("{}", t1.elapsed().as_millis());
            println!("{} = {}", sum1, sum2);
        }
    }
}
222
249
20000 = 20000

Loop optimization

In my tests, using skip and take with iter() is slower than accessing indexes from a range directly. And using get_unchecked with a range is the fastest approach.

A main goal of using Rust is to achieve excellent performance. With skip and take, we can narrow down a loop in a safe way. But unsafe code, and direct index accesses, may be faster.