Java

1388 readers

1 users here now

For discussing Java, the JVM, languages that run on the JVM, and other related technologies.

founded 1 year ago

MODERATORS

Ategon

JackbyDev

thtroyer

Erasure: how we got the generics we have, or how I learned to stop worrying and love erasure (cr.openjdk.org)

submitted 1 year ago by JackbyDev to c/java

15 comments fedilink hide all child comments

A great read for folks wondering why Java uses type erasure instead of "reified" generics. For the unaware, that means that a List<Integer> is a List<Object> at runtime. I had always wondered about it and why they didn't take the alternative route. For context, C# does have reified types so the actual type parameter is available at runtime.

I personally love reading in depth discussions about counter intuitive engineering decisions like this.

you are viewing a single comment's thread
view the rest of the comments

[–] JackbyDev 1 points 1 year ago (1 children)

I'm not familiar with Scala, but doesn't it have a different form of generic typing? Like isn't there a way to explicitly say if you want co- or contravariance? Maybe it's not totally compatible.

But yeah, even as an exclusive Java developer the only time I have to do something like this is when you're doing something like deserializing JSON and need a type parameter. As an example you can tell it, "Hey, I expect this is LocalDate.class" but if you need something like a List<LocalDate> you can't do that with the .class syntax. Weirdly, anonymous inner classes do store type parameters so the way most frameworks handle it is something like new TypedParamter<List<LocalDate>> {}. I'm not sure if there is a way for frameworks to get around it, I just know that's the only real time I see it.

[–] [email protected] 2 points 1 year ago (3 children)

Scala does have a way of specifying co-/contravariance, but Java actually does have that, too. In Java, you write <? extends T> for covariance and <? super T> for contravariance. Well, and generally, Scala's generics are compatible with Java's. It's quite common to use Java libraries in Scala.

One example where type erasure causes problems (which should be the same in Java):
Imagine, you're managing sensors and all of those sensors have a generic to remember what element will be produced by them: Sensor, Sensor etc.
If you want to keep all of those Sensors in one big list/map, you end up with a Sensor when you take them back out.

To retain type information, you have to put them into individual lists or somehow place a runtime type next to each element in the list, from which you can determine what to cast to.

I guess, in languages without type erasure, it doesn't let you place a Sensor into the same list as a Sensor to begin with, as those are strictly different types.
But of course, those languages may offer ways of doing type erasure anyways, and obviously, you can fall back to a common interface/supertype, if the types have that.

[–] JackbyDev 2 points 1 year ago* (last edited 1 year ago) (1 children)

As a heads up, idk if it is just the Jerboa app or Lemmy but I your type params on Sensor were being interpreted as HTML tags and not rendered. The ones in the first paragraph are fine though.

Can we use raw HTML?

Edit: looks like it just gets blocked and not read.

Edit 2: Looks like Jerboa and the browser display this differently actually lol

[–] [email protected] 1 points 1 year ago (1 children)

Funnily enough, I typed that one in the Jerboa app, but yeah, it's not rendering for me either. 🙃

[–] JackbyDev 2 points 1 year ago

I opened a GitHub issue. I think it's probably just a config thing as they are both based on the CommonMark spec. Or maybe a nug with one of the markdown libs themselves.

[–] kaba0 1 points 1 year ago

Note that Java’s generics are on the library-side, while Scala’s is defined at use site.

[–] kaba0 1 points 1 year ago

Note that Java’s generics are on the library-side, while Scala’s is defined at use site.