Type-checker cannot infer type if it passes through some traits with associated types

[illicitonion]

See repro at https://github.com/illicitonion/repro-rustfuturetypeinference

For a trait type with two type parameters, if one arm of a match leaves one of the type parameters unbound, I need to explicitly cast its value to bind the type parameter to match that of the other arms.

I expect that the type-checker should be able to properly infer this type (at least for simple cases).

[stephaneyfx]

I think this is not a bug, meaning the compiler is not supposed to infer the type Box<Trait> in your case as it has too little information to identify Trait. Such inference would not be possible in the case of types implementing more than one trait in common and even in that case, the inference would break as soon as both types implement a new common trait. For example:

trait Foo {}
trait Bar {}

struct A;
impl Foo for A {}
impl Bar for A {}

struct B;
impl Foo for B {}
impl Bar for B {}

fn main() {
    // Should the compiler infer `x` to be of type `Box<Foo>` or `Box<Bar>`?
    let x = match true {
        true => Box::new(A),
        false => Box::new(B),
    };
    drop(x);
}

[arielb1]

There's no reason the compiler would figure out you meant you want to coerce both of your arms to Box<Future> without you specifying anything. The compiler can't know you don't e.g. want to coerce your type to say Box<std::fmt::Debug>.

[arielb1]

The preferred way to fix this is to provide a coercion hint:

let x: BoxFuture<_, _> = match true {
    true => ...,
    false => ...
};