Odpowiedź.

Historia pytania

W języku Rust, podobnie jak w wielu nowoczesnych językach programowania, wprowadzono system wnioskowania typów (type inference), który pomaga programistom zaoszczędzić czas i zmniejszyć ilość powtarzającego się kodu. Został on wprowadzony w Rust praktycznie od samego początku, aby ułatwić statyczne typowanie bez potrzeby jawnego określania typu zmiennej w każdym przypadku.

Problem

Chociaż wnioskowanie typów przyspiesza pracę i czyni kod bardziej zwięzłym, jego zbyt częste lub niekontrolowane użycie może prowadzić do pojawiania się nieoczywistych błędów, obniżenia czytelności i nieprzewidywanych problemów z wydajnością. Nie w każdym miejscu kompilator może poprawnie lub jednoznacznie określić typ. Niektóre konstrukcje Rust wymagają jawnych adnotacji, w przeciwnym razie kod nie skompiluje się.

Rozwiązanie

Rust wspiera lokalne (lokalny zakres) i kontekstowe wnioskowanie typów. Najczęściej wnioskowanie typów działa dla zmiennych, wartości zwracanych przez funkcje, a także dla wyrażeń let wewnątrz funkcji. W wszystkich innych przypadkach (np. przy deklaracji struktur, sygnatur funkcji, funkcji generycznych) typy muszą być podane jawnie.

Przykład kodu:

let x = 10; // x: i32 (domyślnie)
let y = vec!["hello", "world"]; // y: Vec<&str>

fn add<T: std::ops::Add<Output = T>>(a: T, b: T) -> T {
    a + b
}
let sum = add(2u16, 3u16); // sum: u16

Kluczowe cechy:

Rust wykonuje wnioskowanie typów tylko w obrębie ograniczonego zakresu, po wyrażeniu po prawej stronie znaku =.
Adnotacje typów są obowiązkowe w publicznych API, kodzie generycznym, strukturach i traitach.
Nieoczywiste lub zbyt "ogólne" typy obniżają czytelność i wsparcie kodu, nawet jeśli kompilator je wnioskować.

Pytania z pułapką.

Czy kompilator Rust może wnioskować typ funkcji, jeśli nie wskaże się jawnie wartości zwracanej?

Nie, w sygnaturze funkcji typ wartości zwracanej zawsze musi być jawnie podany, w przeciwnym razie wystąpi błąd kompilacji.

// Wystąpi błąd:
fn func() { 42 }
// Powinno być tak:
fn func() -> i32 { 42 }

Czy można w pełni polegać na wnioskowaniu typów podczas pracy z kolekcjami lub referencjami?

Często wymagana jest jawna adnotacja, szczególnie z referencjami mutable/immutable oraz skomplikowanymi kolekcjami generycznymi, aby uniknąć niejasności lub uzyskać wymagany typ.

let data = Vec::new(); // data: Vec<()> — nie zawsze oczekiwany typ
let numbers: Vec<i32> = Vec::new(); // jawnie wskazane

Jak działa wnioskowanie typów przy użyciu zamknięć i parametrów funkcji?

Kompilator może wnioskować typy parametrów zamknięć na podstawie kontekstu, ale nie zawsze — czasami wymagana będzie pełna adnotacja.

let plus_one = |x| x + 1; // błąd: nie można wnioskować typu x
let plus_one = |x: i32| x + 1; // kompiluje się

Typowe błędy i antywzorce

Całkowite poleganie na wnioskowaniu typów bez jawnych typów w skomplikowanym kodzie prowadzi do zapychania kodu błędami, obniżenia wsparcia i czytelności.
Użycie Vec::new() lub HashMap::new() bez jawnych parametrów generycznych często prowadzi do nieoczekiwanych rezultatów.

Przykład z życia

Negatywny przypadek

Programista napisał funkcję API z całkowicie nieoznakowanymi parametrami i lokalnymi zmiennymi bez wskazania typu — cały kod polegał wyłącznie na wnioskowaniu typów. Zespół napotkał wiele niestandardowych błędów i zamieszania: nie było jasne, jakich dokładnie typów oczekują parametry i co właściwie zwraca funkcja.

Zalety:

Mniej kodu
Szybkie tworzenie prostego prototypu

Wady:

Bardzo słaba dokumentacja API
Błędy podczas modyfikacji kodu
Trudność w debugowaniu

Pozytywny przypadek

Inny zespół używał wnioskowania typów tylko dla lokalnych zmiennych w prostych wyrażeniach, a w wszystkich publicznych API, strukturach generycznych i funkcjach zawsze jawnie określał typy. W rezultacie wsparcie i zrozumienie kodu znacznie się poprawiły, liczba błędów spadła.