Would Type Inference Help Java?
My former colleague Lars Westergren recently posted a blog (here)
about type inferencing, posing the question whether type inference
would actually be good for Java, and if it would provide any benefits
outside of just "less typing".
In short: no. Type inferencing would probably not do much more than save you some typing. But how much typing it would save you could definitely vary depending on the type of type inference you added. The one version I would probably prefer is just a very simple hack to avoid writing out the generic type arguments. One simple way of doing that would be to allow an equals sign inside of the angle brackets. In that case you could do this:
List<=> l = new ArrayList<String>();Of course, you can do it on more complicated expressions:
List<String> l2 = new ArrayList<=>();
List<Set<Map<Class<?>, List<String>>>> l = new ArrayList<=>();
would save us some real pain in the definition of genericized types,
and it wouldn't strip away much stuff you need for readability. In the
above examples it would just strip away one duplication, and you don't
need that duplication to read it correctly. The one case where it might
be a little bit harder to read would be if you defined a variable and
assigned it somewhere else. In that case the definition would need to
carry the type information, so the instantiation would use the
<=> syntax. I think that would be an acceptable price to reduce
the verbosity of Java generics.
Another kind of generics that would be somewhat useful is the kind added to C#, which is only local to a scope. That means there will be no type inferencing of member variables, method parameters or return values. Of course, that's the crux of Lars question, since this kind of type inference potentially removes ALL type information in the current text, since you can do:
var x = someValue.DoSomething();
this point there is no easy way for you to know what the type of x
actually is. Reading it like this, it looks a bit frightening if you're
used to Java type tags, but in fact this is not what you would see. In
most cases you have a small method - maybe 5-15 lines of code, where x
is being used in some way or another. In many cases you will see
methods called on x, or x used as argument to method calls. Both of
these usages gives you clues about what it might be, but in fact you
don't always need to know what type it is. You just need to know what
you can do with it. And that's exactly what Java interfaces represent.
So for example, do you know what class you get back from
Collections.synchronizedMap()? No, and you shouldn't need to know. What
you do know is that it's something that implements Map, and the
documentation says that it is synchronized, but that is it. The only
thing you know about it is that you can use it as a map.
So in practice, the kind of type inference C# adds is actually quite useful, clean, and doesn't cause too much trouble - especially if you have one of those fancy ideas that do method completion... =)
From another angle, there are some things that type inference could possible do, but that you will never see in Java. For example, say that you assign a variable to something, and later you assign that variable to some other value. If these two values are distinct types that doesn't overlap in the inheritence chain, you will usually get an error. But if you have an advanced type system, it will do unification for you. The basic versions will just find the most common supertype (the disjunction), but you can also imagine the compiler injecting a new type into your program that is the union of the two types in use. This will provide something similar to duck typing while still retaining some static type safety. If your type system allows multiple inheritence, the synthetic union type might even be a subclass of both the types in question.
So yeah. The long answer is that you can actually do some funky stuff with type inference that doesn't immediately translate to less typing. Although less typing and better abstractions is what programming languages are all about, right? Otherwise assembler provides everything we want.