Closure Fn* trait coercion removes other implementable Fn* traits

[konnorandrews]

I tried this code:

fn demo<F: FnOnce()>(f: F) -> F { f }

fn other<F: Fn()>(_f: F) {}

fn main() {
    let x = || ();
    other(x); 
    
    let x = demo(|| ());
    other(x); 
}

I expected to see this happen: The code to compile.

Instead, this happened: Compilation failed stating the second x does not implement Fn.

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
  --> src/main.rs:9:18
   |
9  |     let x = demo(|| ());
   |                  ^^ this closure implements `FnOnce`, not `Fn`
10 |     other(x); 
   |     ----- - the requirement to implement `Fn` derives from here
   |     |
   |     required by a bound introduced by this call
   |
note: required by a bound in `other`
  --> src/main.rs:3:13
   |
3  | fn other<F: Fn()>(_f: F) {}
   |             ^^^^ required by this bound in `other`

playground

I would expect this to either compile fine (which means changing something about how closure coercion works) or for the diagnostic given to point at the coercion to a FnOnce for the reason why it doesn't implement the Fn trait.

Meta

rustc --version --verbose:

rustc 1.80.1 (3f5fd8dd4 2024-08-06)
binary: rustc
commit-hash: 3f5fd8dd41153bc5fdca9427e9e05be2c767ba23
commit-date: 2024-08-06
host: x86_64-unknown-linux-gnu
release: 1.80.1
LLVM version: 18.1.7

[ryanavella]

Curiously it can be made to compile with an intermediate binding.

-   let x = demo(|| ());
+   let x = || ();
+   let x = demo(x);
    other(x); 

[compiler-errors]

Yep, this is a consequence of the closure signature inference algorithm. Removing this would cause other code to fail to compile, since forcing a closure to be FnOnce changes how it borrows things in subtle ways.

Is there a reason you reported this other than the example you shared?

[konnorandrews]

Is there a reason you reported this other than the example you shared?

Yes, I encountered this in the wild while working on an extension trait. The constructor had a FnOnce bound accidentally while the implementation used a Fn.

error[E0525]: expected a closure that implements the `Fn` trait, but this closure only implements `FnOnce`
  --> examples/brainfuck.rs:39:33
   |
21 | fn parser_<Input>() -> impl ImplParser<Input, Vec<Instruction>, (), DynError>
   |                        ------------------------------------------------------ the requirement to implement `Fn` derives from here
...
39 |         .map_err::<DynError, _>(|err| DynError(err.to_string()))
   |                                 ^^^^^ this closure implements `FnOnce`, not `Fn`
   |
   = note: required for `MapErr<Map<NoSuspend<(Many<To<Token<Input>, Instruction>, Vec<Instruction>>, Token<Input>)>, ...>, ...>` to implement `Parser<I
nput>`
   = note: required for `MapErr<Map<NoSuspend<(Many<To<Token<Input>, Instruction>, Vec<Instruction>>, Token<Input>)>, ...>, ...>` to implement `ImplPars
er<Input, Vec<Instruction>, (), DynError>`
   = note: the full name for the type has been written to ''
   = note: consider using `--verbose` to print the full type name to the console
   = note: the full name for the type has been written to ''
   = note: consider using `--verbose` to print the full type name to the console

pub trait CombinatorExt<I: Stream>: Parser<I> + Sized {
    ...
    
    fn map_err<E, F>(self, f: F) -> MapErr<Self, F>
    where
        I: Stream,
        F: FnOnce(Self::Error) -> E, // bound is too strict, but this bound isn't actually needed anyways. its only here for earlier error reporting to the user and to help inference
        E: Recover<I, Self::State>,
        E: fmt::Debug + fmt::Display,
    {
        MapErr { inner: self, f }
    }
    
    ...
}

impl<I, T, F, E> Parser<I> for MapErr<T, F>
where
    I: Stream,
    T: Parser<I>,
    F: Fn(T::Error) -> E, // the bound actually needed for the impl
    E: Recover<I, T::State>,
    E: fmt::Debug + fmt::Display,
{
    ...
}

fn parser_<Input>() -> impl ImplParser<Input, Vec<Instruction>, (), DynError> // errors also points here
where
    Input: Stream<Token = StrToken>,
{
    use Instruction::*;

    let parser = (token('<').to(Left).many(), token(()));

    parser
        .no_suspend()
        .map::<Vec<Instruction>, _>(|((i, _err), _)| {
            i
        })
        .map_err::<DynError, _>(|err| DynError(err.to_string())) // line the error points at
}