Fn is assumed when reference is passed as Pattern

[heav-4]

Sorry, I don't exactly understand why this happened, so I can't provide much more detail.

error[E0277]: expected a `std::ops::Fn<(char,)>` closure, found `char`
  --> hglfgp_glsl/src/lib.rs:21:42
   |
21 |     s.chars().filter(|c| !(" \n\t".contains(c))).collect::<String>()
   |                                             ^ expected an `Fn<(char,)>` closure, found `char`

The correct solution to fix this was to change |c| to |&c|, however the error message did not indicate what was wrong at all.
Please inform me if I need to change the format of this issue.

[Plecra]

Here's a full version of the error

error[E0277]: expected a `Fn<(char,)>` closure, found `char`
   --> src/lib.rs:1:36
    |
1   | const _: fn(&str, &char) -> bool = str::contains;
    |                                    ^^^^^^^^^^^^^ expected an `Fn<(char,)>` closure, found `char`
    |
    = help: the trait `Fn<(char,)>` is not implemented for `char`
    = note: required because of the requirements on the impl of `FnOnce<(char,)>` for `&char`
    = note: required because of the requirements on the impl of `Pattern<'_>` for `&char`

I'm not sure how this could be improved. The error contains the full explanation of why this trait bound was tested, and the fundamental problem of Pattern<_> being missing is included in the last note.

This behaviour (of attempting to follow generic implementations) is often very useful, and I definitely wouldn't want it to be removed entirely

Edit: It was pointed out that #62981 added a special case hint for this issue

[camelid]

@heav-4

Please inform me if I need to change the format of this issue.

In general it is helpful if you provide source code; preferably a minimized example.

[camelid]

Here's a full repro:

fn main() {
    let s = String::from("Hello, world!");
    s.chars().filter(|c| !(" \n\t".contains(c))).collect::<String>();
}

(Playground)

Errors:

   Compiling playground v0.0.1 (/playground)
error[E0277]: expected a `Fn<(char,)>` closure, found `char`
 --> src/main.rs:3:45
  |
3 |     s.chars().filter(|c| !(" \n\t".contains(c))).collect::<String>();
  |                                             ^ expected an `Fn<(char,)>` closure, found `char`
  |
  = help: the trait `Fn<(char,)>` is not implemented for `char`
  = note: required because of the requirements on the impl of `FnOnce<(char,)>` for `&char`
  = note: required because of the requirements on the impl of `Pattern<'_>` for `&char`

error: aborting due to previous error

For more information about this error, try `rustc --explain E0277`.
error: could not compile `playground`

To learn more, run the command again with --verbose.

---

I also find this error confusing (primarily since it says that char is not a closure, which is not the actual problem), but also am not sure of a good way to improve it.

[SNCPlay42]

I think the reasoning could be more easily understood if it was displayed "the other way up":

error[E0NNN]: the trait `Pattern<'_>` is not implemented for `&char`
 --> src/main.rs:3:45
  |
3 |     s.chars().filter(|c| !(" \n\t".contains(c))).collect::<String>();
  |                                             ^
  |
  = note: an `impl<'a, F> Pattern<'a> for F` exists but is not satisified...
  = note: because `&char` does not implement `FnOnce<(char,)>`...
  = note: an `impl<'_, A, F> FnOnce<A> for &'_ F ` exists but is not satisified...
  = note: because `char` does not implement `FnOnce<(char,)>`

[ibraheemdev]

I ran into this issue as well with one of my own traits:

trait Foo {
    fn foo(&self) -> String;
}

impl<F> Foo for F where F: Fn() -> String {
    fn foo(&self) -> String {
        self()
    }
}

fn foo(foo: impl Foo) -> String {
    foo.foo()
}

fn bar(x: Box<dyn Foo>) {
    foo(x);
}

error[E0277]: expected a `Fn<()>` closure, found `dyn Foo`
  --> src/lib.rs:16:9
   |
11 | fn foo(foo: impl Foo) -> String {
   |                  --- required by this bound in `foo`
...
16 |     foo(x);
   |         ^ expected an `Fn<()>` closure, found `dyn Foo`
   |
   = help: the trait `Fn<()>` is not implemented for `dyn Foo`
   = note: wrap the `dyn Foo` in a closure with no arguments: `|| { /* code */ }`
   = note: required because of the requirements on the impl of `Fn<()>` for `Box<dyn Foo>`
note: required because of the requirements on the impl of `Foo` for `Box<dyn Foo>`
  --> src/lib.rs:5:9
   |
5  | impl<F> Foo for F where F: Fn() -> String {
   |         ^^^     ^

Compiles with an explicit impl Foo for Box<dyn Foo>.

[estebank]

Current output:

error[E0277]: expected a `Fn(char)` closure, found `char`
 --> src/main.rs:3:45
  |
3 |     s.chars().filter(|c| !(" \n\t".contains(c))).collect::<String>();
  |                                    -------- ^ expected an `Fn(char)` closure, found `char`
  |                                    |
  |                                    required by a bound introduced by this call
  |
  = help: the trait `Fn<(char,)>` is not implemented for `char`
  = note: required for `&char` to implement `FnOnce<(char,)>`
  = note: required for `&char` to implement `Pattern<'_>`
note: required by a bound in `core::str::<impl str>::contains`
 --> /rustc/6b771f6b5a6c8b03b6322a9c77ac77cb346148f0/library/core/src/str/mod.rs:1055:5
help: consider dereferencing here
  |
3 |     s.chars().filter(|c| !(" \n\t".contains(*c))).collect::<String>();
  |                                             +

error[E0277]: expected a `Fn()` closure, found `dyn Foo`
  --> src/lib.rs:16:9
   |
16 |     foo(x);
   |     --- ^ expected an `Fn()` closure, found `dyn Foo`
   |     |
   |     required by a bound introduced by this call
   |
   = help: the trait `Fn<()>` is not implemented for `dyn Foo`
   = note: wrap the `dyn Foo` in a closure with no arguments: `|| { /* code */ }`
   = note: required for `Box<dyn Foo>` to implement `Fn<()>`
note: required for `Box<dyn Foo>` to implement `Foo`
  --> src/lib.rs:5:9
   |
5  | impl<F> Foo for F where F: Fn() -> String {
   |         ^^^     ^          -------------- unsatisfied trait bound introduced here
note: required by a bound in `foo`
  --> src/lib.rs:11:18
   |
11 | fn foo(foo: impl Foo) -> String {
   |                  ^^^ required by this bound in `foo`