failed type inference when indexing vec-of-vec in closure

[lolbinarycat]

I tried this code:

fn main() {
    let v: Vec<Vec<u64>> = vec![vec![7]];
    let f = |x, y| v[x][y];
}

I expected to see this happen: code compiles successfully

Instead, this happened:

Compiling playground v0.0.1 (/playground)
error[[E0282]](https://doc.rust-lang.org/stable/error_codes/E0282.html): type annotations needed
 --> src/main.rs:3:20
  |
3 |     let f = |x, y| v[x][y];
  |                    ^^^^ cannot infer type

The strange thing is that type inference for x and y work fine, it's the intermediate temporary's type that can't be inferred.

This snippet works:

fn use_closure(_f: impl Fn(usize, usize) -> u64) {}

fn main() {
    let v: Vec<Vec<u64>> = vec![vec![7]];
    let f = |x, y| -> u64 { 
        let tmp: &Vec<u64> = &v[x];
        tmp[y]
    };
    use_closure(f);
}

Meta

Version: happens with both 1.86.0 stable and 1.88.0-nightly (2025-04-02 d5b4c2e)

[meithecatte]

The strange thing is that type inference for x and y work fine, it's the intermediate temporary's type that can't be inferred.

Nope, if you actually annotate x and y as usize, this works fine. It is expected that inference can't infer this – after all, x and y could be ranges, and the v[x][y] could be doing slicing.

However, the diagnostic is confusing. It would probably make sense to give priority to the fact that the type of x cannot be inferred, as opposed to a random temporary.

@rustbot label +A-diagnostics

[lolbinarycat]

@meithecatte the interesting thing is that the second snippet actually works, and it doesn't work if you don't give tmp a type.

[meithecatte]

@lolbinarycat Yes, because for an Index operation, rustc is able to infer the output type from the index type, or the index type from the output type, but it needs at least one of those to start from.