The type inference for `T` cannot be done when the matched type has the form of `T::Output` and the trait is user-defined but it can be done for `FnTrait`

[xmh0511]

trait MyTrait<T> {
    type Output;
}
impl<T> MyTrait<T> for T {
    type Output = T;
}
fn show<T: MyTrait<T, Output = T> + Default>() -> T::Output {
    T::default()
}

fn main() {
    let i: i32 = show();
}

In this case, the compiler cannot infer the type for T, however, as specified in the trait bound T: MyTrait<T, Output = T>, which implies that T::Output is just T. If we change T::Output to T, then the compiler will infer T as i32.

In contrast, the compiler can infer Fn::Output, for example:

fn infer_output<F,U:Default>(_:F)->F::Output
where F:Fn()->U
{
   U::default()
}
fn function<U:Default>()->U{
    U::default()
}
fn main() {
    let i:i32 = infer_output(function);
}

In this example, the compiler can know that F::Output is U, and infer U with type i32. The compiler may enhance type inference to make it more powerful for the first example.

[steffahn]

I think the conclusion (implied in the current title) that this has anything to do with Fn traits is probably wrong. To me it seems much more likely that the significant difference is how your trait involves Self and Output being the same type for the MyTrait bound and implementation, whereas for your Fn example they are different types.

[steffahn]

For example this works, too:

trait MyTrait<T> {
    type Output;
}
struct F<T>(T);
impl<T> MyTrait<T> for F<T> {
    type Output = T;
}
fn show<T: Default>() -> <F<T> as MyTrait<T>>::Output
where
    F<T>: MyTrait<T, Output = T>,
{
    T::default()
}

fn main() {
    let i: i32 = show();
}

[compiler-errors]

@steffahn is correct. We are never able to do anything productive with a trait predicate that has an infer var as the self type.

This also works (replacing the self type of the MyTrait impl with ()):

trait MyTrait<T> {
    type Output;
}
impl<T> MyTrait<T> for () {
    type Output = T;
}
fn show<T: Default>() -> <() as MyTrait<T>>::Output where (): MyTrait<T, Output = T> {
    T::default()
}

fn main() {
    let i: i32 = show();
}

[steffahn]

@compiler-errors you tagged the wrong person 😉

[compiler-errors]

nh hn transposition, smh