Hacker News Reader

Comment by pents90 | Hacker News Reader

As a long-time Java developer, I really hope they won't implement JEP 286. I think type inference by the compiler is a bad idea, as it results in less readable code, more bugs, and an unnecessary burden on the compiler. I think all the examples where type inference is convenient are trivial cases, but the downsides start to crop up in real-world, large code bases. So it's something that makes the easy things slightly easier and the hard the things harder.

Type inference already happens for you when you are using a good IDE, like IntelliJ IDEA. You can just use the "Introduce Variable" refactoring. And better yet, it self-documents your code with the variable's type.

View on HN

> Less readable code

Maybe it is because we are used to our own paradigms, but the following is no less readable to me because of inference. And these are the 95% of cases.

  var index = 0;
  var name = "pwaivers";
  var names = new List<string>();
  var nameMap = new List<string, Dictionary<int, Address>>();

> more bugs

I have never seen a bug arise because of type inference. Do you have an example?

> unnecessary burden on the compiler

The compiler does a lot of work and this would probably be insignificant to add to it. However, I am totally open to learning more about this.

The examples you've given have direct values. Try:

  var index = getIndexFromSomewhere();
  var name = getHandleFromUser("peter", "waivers")

The type isn't as clear anymore.

*Edit: I'm absolutely a fan of the var syntax, having dabbled with scala. I'm just expressing what I think the original author's complaint is.

I think the code is much more readable and less annoying with inference. And as for your examples, you don't need to know the types - the compiler will complain if you try and use them inappropriately whether the type was explicit or not.

But the issue you have glossed over is that sometimes there is no nominal type - there is only an anonymous type, as for example returned by a LINQ query using new{}, or via monad-style combinators where you really don't want to see the type for fear of your eyes bleeding.

> I think the code is much more readable and less annoying with inference.

I concur. I've been dabbling with Java a bit again (mainly because of a hobby project in order to learn Clojure) after a pause of multiple years.

It boggles my mind that compiler inference didn't make it into the language yet. Everytime I have to declare a totally obvious type, I cringe.

Isn't Java generally considered to be unusable without a decent IDE anyway? I feel like if you need to know what the return type is, the editor should be able to tell you that in these cases.

a) You can optionally include the type if you want. I do this in some rare circumstances where it does create more readable code.

  string name = getHandleFromUser("peter", "waivers")

b) It is usually not necessary to know what the type is while reading code, and if you need to know you can just hover over the variable.

>The type isn't as clear anymore.

It doesn't have to be, as the compiler (and linter) will inform of any misuse of the type later on. And any editor worth its salt could even annotate the type right there.

Yea, I remember the same was said when C# was introducing var, it's a valid concern but in reality it really isn't

The only people I've seen complain much about this were converted VB devs, who mistakenly thought it was shorthand for the godawful VB Variant type, with all of its unintuitive type coercion rules that make JavaScript seem sane.

I think you're suffering from Stockholm syndrome. I have never experienced a bug using scala's type inference that could have been prevented by more required boilerplate. Type inference is 100% benefit with zero drawback.

If you really want to know what a type is resolved to, you have both compilers and IDEs there to tell you. Relying on an IDE to write code is just hacking over a weak or broken language.

To be fair, the compiler errors you get with inferenced types will often lead you to write in the types anyway, to ringfence the bugs. Type inference often gives you really messed up error messages when you've done a mistake.

It's not a compiler burden because it already has to determine the type of the right-hand side for typechecking purposes. So, the compiler actually does less work in the 'var' case, simply assigning the calculated type to the left-hand side rather than checking against a user-supplied type.

Not really. Without type inference, there's always a pretty short path to the type: For "int x = y" you only have to check that the type of y is int. If you have type inference "int x = y" is a lot harder to validate, because y may have been defined like so "var y = z". So now you have to create some kind of list of variables and their types, start at the ones that are explicitly defined like "int a = b" or "c = 5" and then fill in the types of the rest as you find a reference to the ones you know.

>As a long-time Java developer, I really hope they won't implement JEP 286. I think type inference by the compiler is a bad idea, as it results in less readable code, more bugs, and an unnecessary burden on the compiler.

It is already the case in lots of languages since 1990s and the sky has not fallen...

Intellij: View type info [on Mac: Ctrl + Shift + P]. Of any [sub]expression. Whenever you care about that level of detail. On-demand self-documented code.

Rust, ML, Coq and Haskell have type inference and if those four are known for anything it's reliability and bug-free code.

Reply on news.ycombinator.com