Error message for closure that requires |_| is vague

[schneems]

Given the following code: https://play.rust-lang.org/?version=stable&mode=debug&edition=2021&gist=2fecf0a7fbaba8101daba7d1a1ec1837

fn main() {
    let number = 2;
    Some(true).filter({
        if number % 2 == 0 {
            number == 0
        } else {
            number != 0
        }
    });
}

The current output is:

Compiling playground v0.0.1 (/playground)
error[[E0277]](https://doc.rust-lang.org/stable/error-index.html#E0277): expected a `FnOnce<(&bool,)>` closure, found `bool`
 --> src/main.rs:3:23
  |
3 |        Some(true).filter({
  |   ________________------_^
  |  |                |
  |  |                required by a bound introduced by this call
4 |  |         if number % 2 == 0 {
  |  |_________-
5 | ||             number == 0
6 | ||         } else {
7 | ||             number != 0
8 | ||         }
  | ||_________- this tail expression is of type `_`
9 |  |     });
  |  |_____^ expected an `FnOnce<(&bool,)>` closure, found `bool`
  |
  = help: the trait `for<'r> FnOnce<(&'r bool,)>` is not implemented for `bool`
note: required by a bound in `Option::<T>::filter`

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground` due to previous error
Standard Output

Should reference:

|_|

As this is the correct code that compiles:

fn main() {
    let number = 2;
    Some(true).filter(|_| {
        if number % 2 == 0 {
            number == 0
        } else {
            number != 0
        }
    });
}

Using

$ rustc -V
rustc 1.65.0 (897e37553 2022-11-02)

If it helps, I'm trying to find a way to conditionally read in a file only if it exists. I was experimenting with this format:

let blerg = Some(template.target_path.exists()).filter(|_| {
            contents.trim()
                == std::fs::read_to_string(&template.target_path)
                    .unwrap()
                    .trim()
        });

Also worth mentioning in the explanation |_| does not show up at all:

$ rustc --explain E0277 | grep "_"
fn some_func<T: Foo>(foo: T) {
    some_func(5i32); // error: the trait bound `i32 : Foo` is not satisfied
fn some_func<T: Foo>(foo: T) {
    some_func(5i32); // ok!
fn some_func<T>(foo: T) {
    some_func(5i32);
fn some_func<T: fmt::Debug>(foo: T) {
    some_func(5i32);
    // some_func(WithoutDebug);

[asonix]

Filter's predicate must be a type that implements FnOnce(&T) -> bool

a block created with {} does not implement FnOnce, ti's just a block of code

Adding |_| turns the block into the body of a closure, which takes 1 argument but doesn't use the argument

https://doc.rust-lang.org/stable/std/option/enum.Option.html#method.filter

[asonix]

Coming back because I also think there's a cleaner way to do this:

let blerg = if template.target_path.exists() {
    std::fs::read_to_string(&template.target_path).unwrap().trim() == contents.trim()
} else {
    false
};

[schneems]

With some help from social friends https://ruby.social/@Schneems/109384543463801280. I've got some more language to explain what's happening versus what I was expecting.

I Intended to use a closure with no arguments, but {} is a block, not a closure || {} is a closure. This error:

  | ||_________- this tail expression is of type `_`
9 |  |     });
  |  |_____^ expected an `FnOnce<(&bool,)>` closure, found `bool`
  |
  = help: the trait `for<'r> FnOnce<(&'r bool,)>` is not implemented for `bool`
note: required by a bound in `Option::<T>::filter`

especially:

 the trait `for<'r> FnOnce<(&'r bool,)>` is not implemented for `bool`
note: required by a bound in `Option::<T>::filter`

Was confusing to me. Because in my head, I looked at the docs and filter needs a bool...but so I didn't understand what the FnOnce jazz was complaining about. If you're really familiar with this syntax it makes sense and is saying the right thing, that it's expecting a function that returns a boolean instead of simply a boolean, but that wasn't apparent while I was in the moment.

I think in this case, I would have like to be drawn to this section:

3 |        Some(true).filter({
  |   ________________------_^
  |  |                |
  |  |                required by a bound introduced by this call

Maybe something like

3 |        Some(true).filter({
  |   ________________------_^
  |  |                |
  |  |                missing syntax for  `for<'r> FnOnce<(&'r bool,)>`, consider adding `||` 

Which gets me a different error message and eventually leads me to |_| :

3 |     Some(true).filter(|| {
  |                ^^^^^^ -- takes 0 arguments
  |                |
  |                expected closure that takes 1 argument
  |
help: consider changing the closure to take and ignore the expected argument
  |
3 |     Some(true).filter(|_| {
  |                       ~~~

I don't know how difficult such detection/suggestion would be.

[estebank]

CC #27300, #47763