Re:Strong Types and Their Impact on Testing
by jimbokun on Tuesday November 18, 2014 @03:47PM
(#8626240)
"It will implicitly auto-promote types in ways you might not want (i.e. List[Int] :+ String = List[Any])."
Wow, that seems to totally miss the point of using types to help you catch errors.
No, because if you then try to call an Int-specific method on an item from that List[Any], you will still get a compile time error.
Re:Strong Types and Their Impact on Testing
by HolyHaddock on Wednesday November 19, 2014 @06:34AM
(#8629430)
Silently inferring List[Any] is like a null reference. The error that you get told about is in a different place to where the problem that you need to fix is. In this case, the static type system could have been more helpful.
There have been attempts to fix this - WartRemover specifically has a Wart for any uses of Any for example.
Re:Strong Types and Their Impact on Testing
by kod on Wednesday November 19, 2014 @01:26PM
(#8631661)
No, a compile time error is nothing at all like a runtime null pointer exception.
Given that the language supports subtype polymorphism, this is exactly how the type inference should work. Any is the narrowest available supertype.
If you don't like it, there's a pretty simple fix: add an explicit type ascription, which you should be doing for the return values of any methods anyway.
Re:Strong Types and Their Impact on Testing
by dllthomas on Wednesday November 19, 2014 @06:17PM
(#8633344)
It's like a null reference in that both increase the distance between the error and the report of failure, and both have a way of working correctly.
The distinction between compile time failure and runtime failure is an important one, but not the only thing going on.
I'd actually argue that strong vs. weak is a continuum and somewhat subjective. One of my gripes with Scala is that the type system (as used in the field) isn't strong enough. It will implicitly auto-promote types in ways you might not want (i.e. List[Int] :+ String = List[Any]). It can be a strong type system, but the quality of programmers has a huge influence on your experience with Scala. If you have bad programmers who do things the Enterprise Java Way, you can quickly end up with compile-speed issues. But that's another rant. Scala's great for mid-sized projects or when the developers are strong.