Why does the Rust compiler allow index out of bounds?

Question

Can someone explain why this compiles:

fn main() {
    let a = vec![1, 2, 3];
    println!(\"{:?}\", a[4]);
}

When running it, I got:

Answer 1

In order to understand the issue, you have to think about it in terms of what the compiler sees.

Typically, a compiler never reasons about the value of an expression, only about its type. Thus:

• a is of type Vec
• 4 is of an unknown integral type
• Vec implements subscripting, so a[4] type checks

Having a compiler reasoning about values is not unknown, and there are various ways to get it.

• you can allow evaluation of some expression at compile-time (C++ constexpr for example)
• you can encode value into types (C++ non-type template parameters, using Peano's numbers)
• you can use dependent typing which bridges the gap between types and values

Rust does not support any of these at this point in time, and while there has been interest for the former two it will certainly not be done before 1.0.

Thus, the values are checked at runtime, and the implementation of Vec correctly bails out (here failing).