Perché Java non digita l'inferenza?

Mi sono sempre chiesto perché Java non fa l'inferenza del tipo dato che il linguaggio è quello che è e la sua VM è molto matura. Google's Go è un esempio di una lingua con un'eccellente deduzione dei caratteri e riduce la quantità di digitazione che uno deve fare. C'è qualche motivo speciale dietro questa funzione che non fa parte di Java?

Tecnicamente parlando, Java ha inferenza di tipo quando si usano i generici. Con un metodo generico come

public <T> T foo(T t) {
  return t;
}

Il compilatore lo analizzerà e lo capirà quando scrivi

// String
foo("bar");
// Integer
foo(new Integer(42));

Verrà restituita una stringa per la prima chiamata e un numero intero per la seconda chiamata in base a ciò che è stato inserito come argomento. Di conseguenza, si otterrà il corretto controllo in fase di compilazione. Inoltre, in Java 7, si può ottenere qualche tipo di inferenza quando si istanziano generici in questo modo

Map<String, String> foo = new HashMap<>();

Java è abbastanza gentile da riempire le parentesi angolari vuote per noi. Ora perché Java non supporta l' inferenza del tipo come parte dell'assegnazione delle variabili? A un certo punto, c'era una RFE per l'inferenza di tipo nelle dichiarazioni di variabili, ma questa è stata chiusa come "Non risolverà" perché

Gli esseri umani beneficiano della ridondanza della dichiarazione di tipo in due modi. Innanzitutto, il tipo ridondante funge da preziosa documentazione: i lettori non devono cercare la dichiarazione di getMap () per scoprire quale tipo restituisce. In secondo luogo, la ridondanza consente al programmatore di dichiarare il tipo previsto e quindi beneficiare di un controllo incrociato eseguito dal compilatore.

Il collaboratore che ha chiuso questo ha anche notato che sembra "non-java-like", con cui sono d'accordo. La verbosità di Java può essere sia una benedizione che una maledizione, ma rende il linguaggio quello che è.

Naturalmente quel particolare RFE non era la fine di quella conversazione. Durante Java 7, questa funzionalità è stata nuovamente considerata , con alcune implementazioni di test create, tra cui una dello stesso James Gosling. Ancora una volta, questa funzionalità è stata infine eliminata.

Con il rilascio di Java 8, ora otteniamo l'inferenza del tipo come parte di lambdas in quanto tale:

List<String> names = Arrays.asList("Tom", "Dick", "Harry");
Collections.sort(names, (first, second) -> first.compareTo(second));

Il compilatore Java è in grado di esaminare il metodo Collections#sort(List<T>, Comparator<? super T>)e quindi l'interfaccia di Comparator#compare(T o1, T o2)e determinarlo firste seconddovrebbe essere un Stringmodo per consentire al programmatore di rinunciare a dover riformulare il tipo nell'espressione lambda.

Bene, prima di tutto, l'inferenza del tipo non ha nulla a che fare con la maturità del runtime, sia che il runtime sia una CPU di 30 anni o una VM così nuova che i bit siano ancora brillanti. si tratta del compilatore.

Detto questo, è consentito per i generici, il motivo per cui non è consentito per i tipi non generici sembra essere dovuto alla filosofia - non c'è nulla che impedisce ai designer di aggiungerlo.

Aggiornamento: sembra che Java 10 lo supporti —- http://openjdk.java.net/jeps/286

Per quanto ne so, quando Java fu progettato all'inizio degli anni '90, l'inferenza del tipo non era così popolare tra i linguaggi tradizionali (ma era già un concetto molto noto, ad esempio in ML). Quindi, posso immaginare che l'inferenza del tipo probabilmente non era supportata perché Java era indirizzato a programmatori provenienti da C ++, Pascal o altri linguaggi tradizionali che non lo avevano (principio della minima sorpresa).

Inoltre, uno dei principi di progettazione di Java è scrivere esplicitamente le cose per assicurarsi che il programmatore e il compilatore abbiano la stessa comprensione del codice: la duplicazione delle informazioni riduce la possibilità di errori. Certo, può essere una questione di gusti se scrivere qualche altro carattere valga la sicurezza aggiuntiva che fornisce, ma questa è stata la filosofia progettuale seguita per Java: scrivere esplicitamente.

Non so se Java otterrà l'inferenza del tipo in futuro, ma IMO sarebbe una grande rivoluzione per il linguaggio (come ha detto Glenn Nelson, è stato descritto come "un-java-like") e quindi si potrebbe anche considerare di abbandonare il nome Java a favore di un nuovo nome.

Se si desidera utilizzare un linguaggio JVM con inferenza di tipo, è possibile utilizzare Scala.

Posso pensare ad alcune possibili ragioni. Uno è che la digitazione esplicita è auto-documentazione. Java generalmente lo rende una priorità rispetto alla concisione. Un altro motivo potrebbe essere nei casi in cui il tipo è alquanto ambiguo. Come quando un tipo o qualsiasi sottotipo potrebbe soddisfare una routine. Supponiamo che tu voglia usare un Elenco, ma qualcuno arriva e usa un metodo esclusivo di ArrayList. La JIT avrebbe inferito una ArrayList e avrebbe continuato anche se si voleva un errore di compilazione.

Contraddice la consolidata raccomandazione di dichiarare le variabili utilizzando l'interfaccia più generica adatta alle tue esigenze e inizializzarle con una classe di implementazione appropriata, come in

Collection<String> names = new ArrayList<>();

In effetti,

var names = new ArrayList<String>();

non è altro che zucchero sintattico per

ArrayList<String> names = new ArrayList<String>();

Se lo desideri, il tuo IDE può produrlo new ArrayList<String>()dall'espressione con "un clic" (refactor / create variabile locale), ma ricorda che contraddice la raccomandazione "usa interfacce".