Thread by @nipafx

Do you dream of "value types" in Java? So do I! Hence I was thrilled to see that Project Valhalla is slowly coming out of exploration with two draft JEPs.

Here's what they currently propose. 🧵👇🏾

(If you prefer video: https:/www.youtube.com/watch?v=WBvTilbh8S0&t=344s)

1/10

First, why value types? To bridge the divide between

* primitives (fast, no memory overhead) and
* reference types (abstraction, safety, identity)

As is, we sometimes have to choose between performance and design. And we often choose wrongly.

2/10

Draft JEP openjdk.java.net/jeps/8251554 proposes new terminology and JVM rules:

1. Interface `IdentityObject` (the boring part):

* for reference types
* called "identity classes"
* instances are "identity objects"

For identity classes / reference types everything stays as is.

3/10

2. Interface `PrimitiveObject` (the exciting part):

* for a new kind of type
* called "primitive classes"
* instances are "primitive objects"

"JVMs may freely duplicate and re-encode them in an effort to improve computation time, memory footprint, and garbage collection"

4/10

Primitive classes want to make good on Valhalla's promise:

"Codes like a class, works like an int."

See strawman code attached. Details:

* class and fields are implicitly final
* no circular dependency on itself
* no synchronized methods
* more in the JEP

5/10

A bit more terminology on primitive classes:

* `Point p` is a "primitive value"
* `Point.ref p` is a "primitive reference"

Primitive values will be like today's primitives (no `null`, no memory indirection/overhead), primitive references like their wrapper types.

6/10

But this doesn't cleanly map to today's situation because if `Integer` were a primitive class, `Integer i` would be a non-nullable primitive value and `Integer.ref i` the primitive reference. To fix that mismatch, the JEP proposes "reference-favoring primitive classes"…

7/10

… A primitive class can be declared as "reference-favoring". If that were the case for `Point`:

* `Point.val p` is a primitive value
* `Point p` is a primitive reference

Compared to earlier, it's flipped - now references are the default and values need special syntax.

8/10

Got all that? Great! 👍🏾 Because the 2nd draft JEP openjdk.java.net/jeps/8259731 proposes to put it into practice on today's primitives:

1. Turn wrapper classes into reference-favoring primitive classes.
2. Treat primitive type keywords as aliases for their primitive value types.

9/10

That's it for those two draft JEPs. Hope you're as excited as I am, but keep in mind that everything can still change.

FAQ:

* What about generics? ~> A separate draft JEP is coming up.
* When will this be released? ~> Your guess is as good as mine, which is "not 2021".

10/10