Rust: detectar quando "parâmetros de tipo irrestrito" podem ser fornecidos explicitamente para uma chamada fn

Com base em https://github.com/rust-lang/rust/pull/39361 , podemos considerar quando os usuários devem adicionar parâmetros de tipo explícitos a uma chamada fn. Estou imaginando um exemplo assim:

fn foo<T>() { }

fn main() {
    foo();
}

Seria bom sugerir que o usuário escrevesse foo::<T> para algum T explícito. Isso exigirá um pouco de reflexão:

Quando queremos sugerir isso em vez de anotar uma variável local? Eu preferiria anexar a anotação na variável local, mas talvez não se o tipo da variável local for alguma coisa complexa que mencione o tipo não inferido profundamente dentro dela, enquanto anotar a função nos permitiria especificar o tipo não inferido diretamente .

Um exemplo:

fn foo<T>() -> Option<T> { }

fn main() {
    let x = foo();
}

Devemos sugerir rotular x: Option<T> ou foo::<T> ? Este caso é limítrofe, mas se você substituir Option por algum tipo mais complexo, isso inclina ainda mais o equilíbrio.

O que fazemos quando o fn aceita muitos tipos e os conhecemos parcialmente? Evitamos o problema antes do que fazer quando temos algumas informações, mas não todas. Mas parece que aqui pode ser mais importante. Um exemplo:

fn foo<T, U>() -> T { }

fn main() {
    let x: i32 = foo();
}

Aqui sabemos T , mas não U . Devemos sugerir foo::<_, XXX> ? Como expressamos o XXX para indicar ao usuário que isso é o que ele precisa fornecer?

cc @cengizIO -- interessante em perseguir?

cc @estebank @jonathandturner -- pensamentos sobre como expressar?