Rust: mendeteksi kapan "parameter tipe tidak dibatasi" dapat diberikan secara eksplisit ke panggilan fn

Membangun https://github.com/rust-lang/rust/pull/39361 , kami mungkin ingin mempertimbangkan kapan pengguna harus menambahkan parameter tipe eksplisit ke panggilan fn. Saya membayangkan contoh seperti ini:

fn foo<T>() { }

fn main() {
    foo();
}

Akan lebih baik untuk menyarankan agar pengguna menulis foo::<T> untuk beberapa T eksplisit. Ini akan membutuhkan sedikit pemikiran:

Kapan kami ingin menyarankan ini sebagai preferensi untuk memberi anotasi pada variabel lokal? Saya lebih suka melampirkan anotasi pada variabel lokal, tetapi mungkin tidak jika jenis variabel lokal adalah beberapa hal kompleks yang menyebutkan jenis yang tidak disimpulkan jauh di dalamnya, sedangkan membubuhi keterangan fungsi akan memungkinkan kita untuk menentukan jenis yang tidak disimpulkan secara langsung .

Sebuah contoh:

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

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

Haruskah kami menyarankan pelabelan x: Option<T> atau foo::<T> ? Kasus ini adalah garis batas, tetapi jika Anda mengganti Option dengan beberapa jenis yang lebih kompleks, keseimbangan semakin miring.

Apa yang kita lakukan ketika fn mengambil banyak jenis, dan kita mengetahuinya sebagian? Kami mengesampingkan masalah sebelumnya tentang apa yang harus dilakukan ketika kami memiliki beberapa informasi tetapi tidak semua. Tapi rasanya di sini mungkin lebih penting. Sebuah contoh:

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

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

Di sini kita tahu T , tetapi tidak U . Haruskah kami menyarankan foo::<_, XXX> ? Bagaimana kami mengungkapkan XXX untuk menunjukkan kepada pengguna bahwa ini adalah hal yang perlu mereka berikan?

cc @cengizIO -- menarik untuk diikuti?

cc @estebank @jonathandturner -- pendapat tentang cara membuat frasa?