Saya melihat bahwa sudah ada beberapa jawaban yang bagus. Beberapa di antaranya saya akan ulangi tetapi kadang-kadang Anda hanya ingin meletakkan sesuatu dengan kata-kata Anda sendiri. Saya akan berkomentar dengan beberapa contoh dari C ++ karena itu adalah bahasa yang paling saya kenal.
Yang penting tidak pernah tidak bijaksana. Ketik inferensi diperlukan untuk membuat fitur bahasa lainnya praktis. Dalam C ++ dimungkinkan untuk memiliki tipe yang tidak dapat dipisahkan.
struct {
double x, y;
} p0 = { 0.0, 0.0 };
// there is no name for the type of p0
auto p1 = p0;
C ++ 11 menambahkan lambdas yang juga tidak dapat disangkal.
auto sq = [](int x) {
return x * x;
};
// there is no name for the type of sq
Ketik inferensi juga mendukung templat.
template <class x_t>
auto sq(x_t const& x)
{
return x * x;
}
// x_t is not known until it is inferred from an expression
sq(2); // x_t is int
sq(2.0); // x_t is double
Tetapi pertanyaan Anda adalah "mengapa saya, sang programmer, ingin menyimpulkan jenis variabel saya ketika saya membaca kode? Bukankah lebih cepat bagi siapa pun hanya untuk membaca jenisnya daripada memikirkan jenis apa yang ada?"
Ketik inferensi menghilangkan redundansi. Ketika datang untuk membaca kode, kadang-kadang mungkin lebih cepat dan lebih mudah untuk memiliki informasi yang berlebihan dalam kode tetapi redundansi dapat menutupi informasi yang berguna . Sebagai contoh:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
Tidak memerlukan banyak keakraban dengan pustaka standar untuk seorang programmer C ++ untuk mengidentifikasi bahwa saya adalah seorang iterator dari i = v.begin()sehingga deklarasi tipe eksplisit memiliki nilai terbatas. Dengan kehadirannya itu mengaburkan detail yang lebih penting (seperti yang imenunjuk ke awal vektor). Jawaban baik oleh @amon memberikan contoh yang lebih baik dari verbosity membayangi detail penting. Sebaliknya menggunakan inferensi tipe memberikan keunggulan lebih besar pada detail penting.
std::vector<int> v;
auto i = v.begin();
Walaupun membaca kode itu penting, itu tidak cukup, pada titik tertentu Anda harus berhenti membaca dan mulai menulis kode baru. Redundansi dalam kode membuat modifikasi kode lebih lambat dan lebih sulit. Misalnya, saya memiliki fragmen kode berikut:
std::vector<int> v;
std::vector<int>::iterator i = v.begin();
Dalam hal ini saya perlu mengubah tipe nilai vektor untuk mengubah kode menjadi dua kali lipat:
std::vector<double> v;
std::vector<double>::iterator i = v.begin();
Dalam hal ini saya harus memodifikasi kode di dua tempat. Kontras dengan inferensi ketik di mana kode aslinya adalah:
std::vector<int> v;
auto i = v.begin();
Dan kode yang dimodifikasi:
std::vector<double> v;
auto i = v.begin();
Perhatikan bahwa sekarang saya hanya perlu mengubah satu baris kode. Ekstrapolasi ini ke program besar dan inferensi tipe dapat menyebarkan perubahan ke tipe jauh lebih cepat daripada yang Anda bisa dengan editor.
Redundansi dalam kode menciptakan kemungkinan bug. Setiap kali kode Anda bergantung pada dua informasi yang dijaga tetap sama, ada kemungkinan kesalahan. Misalnya, ada ketidakkonsistenan antara kedua jenis dalam pernyataan ini yang mungkin tidak dimaksudkan:
int pi = 3.14159;
Redundansi membuat niat lebih sulit untuk dilihat. Dalam beberapa kasus, tipe inferensi dapat lebih mudah dibaca dan dipahami karena lebih sederhana daripada spesifikasi tipe eksplisit. Pertimbangkan fragmen kode:
int y = sq(x);
Dalam kasus yang sq(x)mengembalikan suatu int, tidak jelas apakah ymerupakan intkarena itu adalah jenis pengembalian sq(x)atau karena sesuai dengan pernyataan yang digunakan y. Jika saya mengubah kode lain sehingga sq(x)tidak lagi kembali int, tidak pasti dari baris itu saja apakah jenis yharus diperbarui. Kontras dengan kode yang sama tetapi menggunakan tipe inferensi:
auto y = sq(x);
Dalam hal ini maksudnya jelas, yharus jenis yang sama dengan yang dikembalikan oleh sq(x). Ketika kode mengubah jenis pengembalian sq(x), jenis yperubahan untuk mencocokkan secara otomatis.
Dalam C ++ ada alasan kedua mengapa contoh di atas lebih sederhana dengan inferensi tipe, inferensi tipe tidak dapat memperkenalkan konversi tipe implisit. Jika jenis pengembaliannya sq(x)bukan int, kompiler dengan diam-diam menyisipkan konversi implisit ke int. Jika tipe kembalinya sq(x)adalah tipe kompleks yang operator int()ditentukan, pemanggilan fungsi tersembunyi ini mungkin rumit.