Comments on: Groovy type crazyness

By: tiago

tiago — Tue, 06 Jan 2009 16:11:35 +0000

Aaron: Thanks for the comment. I guess I was lazy. Equal semantics was more or less obviously the source of the problem and I could have dig deeper myself.

James: I think we are entering the realm of the subjective here. I mean, for me, very personally, metaprogramming is a must have. For me generics are the worse of Java. Your mileage may vary and we might have a lot of interesting discussions around these, but, at the end, personal choices dictate what we find acceptable/desirable.

By: Aaron Tuwhangai

Aaron Tuwhangai — Tue, 06 Jan 2009 05:54:51 +0000

The == operator coerces its arguments to the same type before comparing them, so “0.1 == 0.1D” is coerced to mean “0.1 == 0.1″.

The reason that “0.1 in [0.1D]” returns false is that “0.1.equals(0.1D)” also returns false. This correctly follows the Java rules for equals() rather than being a Groovy thing.

By: James Iry

James Iry — Tue, 06 Jan 2009 03:45:19 +0000

So you don’t like Scala because its inference isn’t as complete as Caml, but you like to use explicit types in Groovy?

There have been some updates to dynamic metaprogramming in Scala via something called Manifests which are, in part, a way to reify generic type parameters. But any serious metaprogramming that Scala gets will likely be syntactic metaprogramming a’la template Haskell or Nemerle. Don’t expect the dynamic metaprogramming found in Ruby and Groovy.

Generics aren’t the worst thing in Java by a long shot. Not even erasure is (after all, Caml’s type system is implemented entirely with erasure).

By: tiago

tiago — Mon, 05 Jan 2009 23:14:11 +0000

James, First, thanks for your insightful comments. I have to say I have started with Scala (and migrated to Groovy). I guess am a metaprogramming freak. A summary of my reasons can be found here. It would be fantastic to know that there are updates on the metaprogramming part. I fully agree with our assessment of parametric types. Generics are the worse thing I can thing of in Java.

By: James Iry

James Iry — Mon, 05 Jan 2009 22:54:21 +0000

In this comment I’m using square brackets instead of angle brackets to prevent them from being eaten.

This isn’t a problem related to different numeric types. Groovy is essentially a dynamically typed language. It has (almost) no static type system.

Even when you give type annotations like “List[Double]” you are specifying a runtime check, not a static check. And that runtime check is unfortunately very simple: it has to be a List, but Groovy doesn’t care what’s in the list. It’s not really Groovy’s fault. In Java, parametric types like List[Double] are erased at runtime to just List, so Groovy has inherited that limitation in its runtime type checking.

groovy:000> List[Double] lst = [1, "hello", new RuntimeException(), "I can be" + " whatever"]
===> [1, hello, java.lang.RuntimeException, I can be whatever]

For a statically typed alternative, check out Scala. Generally it’s a bit more succinct than Groovy except when you really need dynamic meta-programming.

scala> val lst = List(1.0, 2.0, 3.0)
lst: List[Double] = List(1.0, 2.0, 3.0)