Impossible to infer the lifetime parameter of a function parameter when going through a trait

[tomaka]

This code:

fn foo<F, P>(f: F)
    where F: Fn(P),
          P: for<'a> From<&'a str>
{
    f(From::from("test"))
}

fn main() {
    foo(|a: &str| {
        // ...
    })
}

Leads to:

error[E0277]: the trait bound `for<'a> &str: std::convert::From<&'a str>` is not satisfied
  --> <anon>:12:5
   |
12 |     foo(|a: &str| {
   |     ^^^ the trait `for<'a> std::convert::From<&'a str>` is not implemented for `&str`
   |
   = note: required by `foo`

In case you're wondering, there is a impl<T> From<T> for T in stdlib, so &'a str does implement From<&'a str>. To make sure I used a custom trait instead of From and it didn't fix the problem.

Chances are that this is a duplicate of an existing issue, but it's hard for someone not familiar with the internals of rustc like me to know if that's the case.

(Also, any idea for a work-around would be greatly appreciated)

[djzin]

there is a impl<T> From<T> for T in stdlib, so &'a str does implement From<&'a str>

This may be true, but it is not true that &'a str: for<'b> From<&'b str>. Where the bounds are satisfied, the code actually compiles:

fn foo<F, P>(f: F)
    where F: Fn(P),
          P: for<'a> From<&'a str>
{
    f(From::from("test"))
}

struct Unit;

impl<'a> From<&'a str> for Unit {
    fn from(_: &'a str) -> Unit {
        Unit
    }
}

fn main() {
    foo(|_: Unit| {
        // ...
    })
}

[djzin]

Not clear if it helps in your specific use case, but your example would compile with the following:

fn foo<F, P: ?Sized>(f: F)
    where for<'a> F: Fn(&'a P),
          for<'a> &'a P: From<&'a str>
{
    f(From::from("test"))
}

fn main() {
    foo(|_: &str| {
        // ...
    })
}

[tomaka]

This may be true, but it is not true that &'a str: for<'b> From<&'b str>. Where the bounds are satisfied, the code actually compiles:

Indeed, it looks like this works if I then use BuildFrom as a replacement for From:

impl<'a: 'b, 'b> BuildFrom<&'a str> for &'b str {
    fn from(f: &'a str) -> &'b str {
        f
    }
}

[cjgillot]

The bound in the original code is needlessly restrictive. The error is correct.