why does not Rust tuple use square bracket to access elements inside?

user_3882914 0
Viewed 676

As titled.

In Rust, I need to use period syntax to access the elements inside a tuple like below (the x.0):

fn main() { 
    let x: (i32, f64, u8) = (500, 6.4, 1);
    println!("{}", x.0);
}

My question is why Rust does not support using a square bracket syntax to access the elements inside a tuple like below which should be a more consistent way?

fn main() { 
    // !!! this snippet of code would not be compiled !!!
    let x: (i32, f64, u8) = (500, 6.4, 1);
    println!("{}", x[0]);  // pay attention to the use of "x[0]" here.
}
rust
2 Answers

The square bracket indexing syntax in Rust can always be used with a dynamic index. That means that the following code should work:

for i in 0..3 {
    do_something_with(x[i]);
}

Even if the compiler may not know which value i will take, it must know the type of x[i]. For heterogeneous tuple types like (i32, f64, u8) that's impossible. There is no type that is i32, f64 and u8 at the same time, so the traits Index and IndexMut can't be implemented:

// !!! This will not compile !!!

// If the Rust standard library allowed square-bracket indexing on tuples
// the implementation would look somewhat like this:
impl Index<usize> for (i32, f64, u8) {
    type Output = ???; // <-- What type should be returned?

    fn index(&self, index: usize) -> &Self::Output {
        match index {
            0 => &self.0,
            1 => &self.1,
            2 => &self.2,
            _ => panic!(),
        }
    }
}

fn main() {
    let x: (i32, f64, u8) = (500, 6.4, 1);
    for i in 0..3 {
        do_something_with(x[i]);
    }
}

Theoretically the standard library could provide an implementation for homogeneous tuples (i32, i32, i32) etc. but this is a corner case that can easily be replaced by an array [i32; 3]. So there is no such implementation.

user_19419730

Do you mean curly bracket? Or square bracket?

Anyways, if my understanding of your question is a bit accurate,

fn main() {
    let x = [0; 5]; // which creates an array with 5 elements valued 0
    println!(“{}”, x[0]); // prints 0
}

pertains to accessing index 0 in an array named x and printing it. Whilst x.0 means index 0 of a tuple named x.

I’m not sure if we’re on the same page.

Perhaps this might shed a light on you for your question "why," https://doc.rust-lang.org/book/appendix-02-operators.html, look for Table B-8: Tuples. You'll see the Non-Operator Symbol used to access tuple elements (expr.0, expr.1).

And on Table B-10: Square Brackets, you'll see expr[expr], as a way to access elements in a collection.

In my understanding they made it "that way", the "why" they made it that way, I'm not sure where to find them.

user_85585850
Related