Compiler can't unify arg-position `impl Trait` into an HRTB

[Patryk27]

It looks like using arg: impl Trait makes the compiler unable to generalize the entire function-type into HRTB (?), that is:

fn foo(_: &str) {
    //
}

fn bar(_: impl AsRef<str>) {
    //
}

fn zar<T>(_: T) {
    //
}

fn check(_: impl Fn(&str)) {
    //
}

fn main() {
    check(foo); // ok
    check(bar); // err (implementation not general enough)
    check(zar::<&str>); // err (ditto)
}

Using a no-op closure helps:

fn main() {
    check(|x| bar(x));
}

... but is somewhat inconvenient (spotted in the wild at clap-rs/clap#4939).

Note that I'm reporting this is a bug, but I'm not really sure on the category here - it just feels like this code should pass type-checking, but maybe there's some deeper reason why it can't.

[Jules-Bertholet]

@rustbot label A-impl-trait A-traits T-types

[compiler-errors]

Two things: First, This is not limited to APIT. This is just a limitation of generic types.

Second, this is not a bug imo. There is no substitution of ?0 in the following program that satisfies the trait bound. This has to do with the early-bound/late-bound distinction of generics, and the fact that Rust has no higher-ranked types.

fn higher<T: for<'a> Fn(&'a str)>(_: T) {}

fn main() {
    higher(std::mem::drop::<_ /* ?0 */>);
}

[Patryk27]

I see - well, it's just a bit unfortunate from the user's perspective, because this works:

higher(|x| std::mem::drop(x));

... and then doing the "natural" thing of unwrapping the extra closure breaks the code:

higher(std::mem::drop);

👀