Poor suggestions wrt closure type/lifetime inference

[ijackson]

Given the following code:

fn main() {
    let cl = |x| { x.split_at(0) };
    let (_x, _y) = cl("42");
}

rustc suggests:

3 |     let cl = |x| { x.split_at(0) };
  |               ^ consider giving this closure parameter a type

Unfortunately, specifying a closure parameter type casts the user from the frying pan into the fire:

error[E0495]: cannot infer an appropriate lifetime for autoref due to conflicting requirements
 --> src/main.rs:3:27
  |
3 |     let cl = |x:&str| { x.split_at(0) };
  |                           ^^^^^^^^
  |
note: first, the lifetime cannot outlive the anonymous lifetime #1 defined on the body at 3:14...
 --> src/main.rs:3:14
  |
3 |     let cl = |x:&str| { x.split_at(0) };
  |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
note: ...so that reference does not outlive borrowed content
 --> src/main.rs:3:25
  |
3 |     let cl = |x:&str| { x.split_at(0) };
  |                         ^
note: but, the lifetime must be valid for the call at 4:20...
 --> src/main.rs:4:20
  |
4 |     let (_x, _y) = cl("42");
  |                    ^^^^^^^^
note: ...so type `(&str, &str)` of expression is valid during the expression
 --> src/main.rs:4:20
  |
4 |     let (_x, _y) = cl("42");
  |                    ^^^^^^^^

Helpful contributors on #rust-beginners found #55526 #56537 and the following simple workaround:

fn main() {
    let cl = |x| { let x : &str = x; x.split_at(0) };
    let (_x, _y) = cl("42");
}

The underlying problem with lifetime inference in closures seems quite tricky and I guess it will remain like this for a while.

Under the circumstances, it would be nice if the compiler could make more helpful suggestions, including the trick with the let binding to nail the type.

Something like this maybe:

Consider removing the type specification for this closure parameter to allow lifetime inference. If the type specification is needed within the closure, a binding let VAR : TYPE = VAR at the start of the closure may help.

(for outputting, in addition to the other messages, in the more complicated lifetime problem case)

[estebank]

Fur your own reference, the following code also works:

fn main() {
    let cl: for<'a> fn(&'a str) -> (&'a str, &'a str) = |x| { x.split_at(0) };
    let (_x, _y) = cl("42");
}

[estebank]

Current output:

error[[E0282]](https://doc.rust-lang.org/stable/error_codes/E0282.html): type annotations needed
 --> src/main.rs:2:15
  |
2 |     let cl = |x| { x.split_at(0) };
  |               ^    - type must be known at this point
  |
help: consider giving this closure parameter an explicit type
  |
2 |     let cl = |x: /* Type */| { x.split_at(0) };
  |                ++++++++++++

error: lifetime may not live long enough
 --> src/main.rs:2:26
  |
2 |     let cl = |x: &str| { x.split_at(0) };
  |                  -   -   ^^^^^^^^^^^^^ returning this value requires that `'1` must outlive `'2`
  |                  |   |
  |                  |   return type of closure is (&'2 str, &str)
  |                  let's call the lifetime of this reference `'1`