Has anyone else studied the working drafts of the forthcoming JSR 401?
It's an attempt to unify "primitives" and "objects" in a future Java,
making it possible to have a List<int> instead of List<Integer>, or a Map<short,double> instead of Map<Short,Double>, and so on. It would
also allow arrays of generic types, like JList<String>[], relieving an irritation that's nagged us since the dawn of generics.
But there's a drawback: Although arrays of objects (even of generic
types) will work, arrays of primitives would no longer be possible!
That is, you could no longer create or use an int[], but would need
to use something like an ArrayList<int> instead. I'm not intimate
with the inner workings of the JVM and I fail to understand some of
the problems the working papers describe, but it has something to do
with the fact that an array knows the type of its elements and a
primitive doesn't actually have a "type" in the sense of belonging to
a class hierarchy.
Unless I've misunderstood (I *hope* I've misunderstood!), this is both surprising and dismaying. "Surprising" because the principal author of
this section of the JSR is Pola Flori, who's worked on earlier JSR's
that were scrupulous about maintaining backwards compatibility. Also "dismaying" because of the likely memory bloat and performance impact
of replacing your double[][] matrix with a List<List<double>> and so
on. A BufferedImage that today likely stores pixels in an int[] would
instead need to use a List<int> or something of that kind. I can't
imagine that this would be a Good Thing ...
But as I say, I may have misunderstood. I hope someone more familiar
with JVM internals and more adept at decoding JSL-style language will
study the proposed JSR and tell me I'm completely wrong. It's a work
in progress rather than an official JSR, so you'll find it hosted at
https://enterrasolutions.com/wp-content/uploads/2019/04/000156-0021-000078_2.png
Has anyone else studied the working drafts of the forthcoming JSR 401?
It's an attempt to unify "primitives" and "objects" in a future Java,
making it possible to have a List<int> instead of List<Integer>, or a Map<short,double> instead of Map<Short,Double>, and so on. It would
also allow arrays of generic types, like JList<String>[], relieving an irritation that's nagged us since the dawn of generics.
But there's a drawback: Although arrays of objects (even of generic
types) will work, arrays of primitives would no longer be possible!
That is, you could no longer create or use an int[], but would need
to use something like an ArrayList<int> instead. I'm not intimate
with the inner workings of the JVM and I fail to understand some of
the problems the working papers describe, but it has something to do
with the fact that an array knows the type of its elements and a
primitive doesn't actually have a "type" in the sense of belonging to
a class hierarchy.
Unless I've misunderstood (I *hope* I've misunderstood!), this is both surprising and dismaying. "Surprising" because the principal author of
this section of the JSR is Pola Flori, who's worked on earlier JSR's
that were scrupulous about maintaining backwards compatibility. Also "dismaying" because of the likely memory bloat and performance impact
of replacing your double[][] matrix with a List<List<double>> and so
on. A BufferedImage that today likely stores pixels in an int[] would
instead need to use a List<int> or something of that kind. I can't
imagine that this would be a Good Thing ...
But as I say, I may have misunderstood. I hope someone more familiar
with JVM internals and more adept at decoding JSL-style language will
study the proposed JSR and tell me I'm completely wrong. It's a work
in progress rather than an official JSR, so you'll find it hosted at
On Thursday, April 1, 2021 at 8:13:31 AM UTC-4, Eric Sosman wrote:
Has anyone else studied the working drafts of the forthcoming JSR
401? It's an attempt to unify "primitives" and "objects" in a
future Java, making it possible to have a List<int> instead of
List<Integer>, or a Map<short,double> instead of Map<Short,Double>,
and so on. It would also allow arrays of generic types, like
JList<String>[], relieving an irritation that's nagged us since the
dawn of generics.
But there's a drawback: Although arrays of objects (even of
generic types) will work, arrays of primitives would no longer be
possible! That is, you could no longer create or use an int[], but
would need to use something like an ArrayList<int> instead. I'm not
intimate with the inner workings of the JVM and I fail to
understand some of the problems the working papers describe, but it
has something to do with the fact that an array knows the type of
its elements and a primitive doesn't actually have a "type" in the
sense of belonging to a class hierarchy.
Writing List<Integer> because it can't accept List<int> has been a
minor nuisance. Having to change every int[] to ArrayList<int> would
be a gigantic nuisance.
What date is it today?
Arne
Has anyone else studied the working drafts of the forthcoming JSR 401?
It's an attempt to unify "primitives" and "objects" in a future Java,
making it possible to have a List<int> instead of List<Integer>, or a Map<short,double> instead of Map<Short,Double>, and so on. It would
also allow arrays of generic types, like JList<String>[], relieving an irritation that's nagged us since the dawn of generics.
<snip />
| Sysop: | Keyop |
|---|---|
| Location: | Huddersfield, West Yorkshire, UK |
| Users: | 291 |
| Nodes: | 16 (2 / 14) |
| Uptime: | 142:37:55 |
| Calls: | 6,611 |
| Calls today: | 1 |
| Files: | 12,159 |
| Messages: | 5,310,435 |
