Why does the Rust documentation say that a while loop over an array is slower than a for loop?

Question

As I was reading the rust documentation, I stumbled upon this code that iterates the array a using a while loop (with an index):

fn main() {
    let a = [10, 20, 30, 40, 50];
    let mut index = 0;

    while index < 5 {
        println!("the value is: {}", a[index]);

        index += 1;
    }
}

The documentation says:

... this approach is error prone; we could cause the program to panic if the index length is incorrect. It’s also slow, because the compiler adds runtime code to perform the conditional check on every element on every iteration through the loop.

The first reason was self-explanatory. The second reason was where I got confused.

Furthermore, they suggested to use a for-loop for this.

fn main() {
    let a = [10, 20, 30, 40, 50];

    for element in a.iter() {
        println!("the value is: {}", element);
    }
}

I just can't seem to wrap my head around this. Is there some kind of behavior that the Rust compiler does?

https://doc.rust-lang.org/reference/expressions/loop-expr.html#iterator-loops, please check the `is equivalent to` part — Ömer Erden, May 28 '19 at 16:33
Think of the operation `a[index]` for an arbitrary slice `a`. What must the program do to ensure that reading the element at position `index` is safe? Now read that paragraph again. — E_net4, May 28 '19 at 16:33

Shepmaster · Accepted Answer · 2019-05-29T13:09:09.270

The two parts are complementary:

we could cause the program to panic if the index length is incorrect.

Every time you write some_slice[some_index], the standard library does the equivalent of:

if some_index < some_slice.len() {
    some_slice.get_the_value_without_checks(some_index)
} else {
    panic!("Hey, stop that");
}

the compiler adds runtime code to perform the conditional check on every element

In a loop, this works out to be something like:

while some_index < limit {
    if some_index < some_slice.len() {
        some_slice.get_the_value_without_checks(some_index)
    } else {
        panic!("Hey, stop that");
    }
    some_index += 1;
}

Those repeated conditionals aren't the most efficient code.

The implementations of Iterator for slices utilize unsafe code to be more efficient at the expense of more complicated code. The iterators contain raw pointers to the data but ensure that you can never misuse them to cause memory unsafety. Without needing to perform that conditional at each step, the iterator solution is often faster¹. It's more-or-less equivalent to:

while some_index < limit {
    some_slice.get_the_value_without_checks(some_index)
    some_index += 1;
}

Why does the Rust documentation say that a while loop over an array is slower than a for loop?

1 Answers1