Type inference fail in a closure

[Yura52]

Let's have a look at two similar closures:

fn foo(v: &Vec<i32>) -> i32 {
    let x: usize = 0;
    let condition = |idx| v[idx] > 0;
    if condition(x) {0} else {1}
}

fn bar(v: &Vec<(i32, i32)>) -> i32 {
    let x: usize = 0;
    let condition = |idx| v[idx].0 > 0;
    if condition(x) {0} else {1}
}

The first one is successfully compiled, but the second one requires additional type annotations: playground 4

It seems that there is enough information for fully automatic type inference in both cases. Is it a compilation bug then?

[hellow554]

Same goes for array and slices

[qnighy]

Dot operators require immediate resolution of outermost non-reference type of the receiver. In this case the compiler has to know that the expression v[idx] is a tuple. However, when the compiler sees the expression for the first time, the type of idx is unknown (it might be Range<usize> for example). So I guess this isn't a bug in a strict sense but there might be a room for improvement in the inference rules.

[Yura52]

Dot operators require immediate resolution of outermost non-reference type of the receiver. In this case the compiler has to know that the expression v[idx] is a tuple. However, when the compiler sees the expression for the first time, the type of idx is unknown (it might be Range<usize> for example). So I guess this isn't a bug in a strict sense but there might be a room for improvement in the inference rules.

Thank you for the explanation. Well, now the question is if the limitation could be less strict :)

[Spoonbender]

triage: no change