Type inference fails to determine closure argument type

[edwardw]

The following fails to compile:

pub fn main() {
  let mut xs = HashMap::<(u32, u32), u32>::new();
  let new_el = |&_| 30;  // error: the type of this value must be known in this context

  xs.insert((1,1), 10);
  xs.insert((2,2), 20);
  xs.find_or_insert_with((3,3), new_el);

  println!("{}", xs);
}

The argument type must be explicitly spelled out:

let new_el = |_: &(u32, u32)| 30;

Should the type inference work here?

[huonw]

What happens of you write the definition of new_el inline at the point-of-use?

[edwardw]

If writing inline at the point of use, it works:

xs.find_or_insert_with((3,3), |_| 30);

[steveklabnik]

This API is gone now, and I am bad with the new Entry API. @gankro ?

[Gankra]

use std::collections::HashMap;

pub fn main() {
  let mut xs = HashMap::<(u32, u32), u32>::new();
  let new_el = |v| v.insert(30);  // error: the type of this value must be known in this context

  xs.insert((1,1), 10);
  xs.insert((2,2), 20);
  xs.entry((3,3)).get().unwrap_or_else(new_el);

  println!("{}", xs);
}

<anon>:5:20: 5:32 error: the type of this value must be known in this context
<anon>:5   let new_el = |v| v.insert(30);  // error: the type of this value must be known in this context
                            ^~~~~~~~~~~~
<anon>:5:16: 5:32 error: can't infer the "kind" of the closure, explicitly annotate it. e.g. `|&:| {}`
<anon>:5   let new_el = |v| v.insert(30);  // error: the type of this value must be known in this context
                        ^~~~~~~~~~~~~~~~
<anon>:11:18: 11:20 error: the trait `core::fmt::String` is not implemented for the type `std::collections::hash::map::HashMap<(u32, u32), u32>`
<anon>:11   println!("{}", xs);
                           ^~
note: in expansion of format_args!
<std macros>:2:42: 2:75 note: expansion site
<std macros>:1:1: 2:77 note: in expansion of println!
<anon>:11:3: 11:22 note: expansion site
error: aborting due to 3 previous errors
playpen: application terminated with error code 101
Program ended.

Seems to basically do the same thing.

[eefriedman]

Another related testcase:

#![feature(std_misc)]
use std::collections::HashMap;
use std::collections::hash_map::VacantEntry;
pub fn main() {
  let mut xs = HashMap::<(u32, u32), u32>::new();
  let new_el = |v:VacantEntry<(u32, u32),u32>| v.insert(30);
  xs.insert((1,1), 10);
  xs.insert((2,2), 20);
  xs.entry((3,3)).get().unwrap_or_else(new_el);
  println!("{:?}", xs);
}

gives error: cannot infer an appropriate lifetime for lifetime parameter 'a due to conflicting requirements

[arcnmx]

Have another related/simplified test case:

(|x| x.count())(0u8..5)

fails to resolve, while the following works:

(|x: ::std::ops::Range<_>| x.count())(0u8..5)

[steveklabnik]

Triage: this issue is kind of a general one, with lots of cases. I'm not sure how much of this is intended to get resolved, and how much of this is scatted across other issues on the tracker.

[steveklabnik]

#27828 has another instance of this.

[estebank]

Current output:

error[E0282]: type annotations needed
 --> src/main.rs:4:16
  |
4 |   let new_el = |&_| 30;  // error: the type of this value must be known in this context
  |       ------   ^^^^^^^ cannot infer type for `[closure@src/main.rs:4:16: 4:23]`
  |       |
  |       consider giving `new_el` a type

Edit: current output:

error[E0282]: type annotations needed for the closure `fn(&_) -> i32`
 --> src/main.rs:4:16
  |
4 |   let new_el = |&_| 30;  // error: the type of this value must be known in this context
  |                ^^^^^^^ cannot infer type for `[closure@src/main.rs:4:16: 4:23]`
  |
help: give this closure an explicit return type without `_` placeholders
  |
4 |   let new_el = |&_| -> i32 { 30 };  // error: the type of this value must be known in this context
  |                     ^^^^^^^^    ^

[sweihub]

Current output with the rust book example, cannot inference the simple type!

example from the rust book

let example_closure = |x| x;

output

swei@macbook:~/code/examples/workday/src
$ rustc --version
rustc 1.41.0-nightly (412f43ac5 2019-11-24)

swei@macbook:~/code/examples/workday/src
$ cargo build
   Compiling workday v0.1.0 (/Users/swei/code/examples/workday)
error[E0282]: type annotations needed
 --> src/main.rs:6:28
  |
6 |     let example_closure = |x| x;
  |                            ^ consider giving this closure parameter a type