rust-ecosystem VS amber-docs

These are issues that I'm aware of that are "tracking" the status of Rust on console:

* <https://github.com/rust-gamedev/wg/issues/90>

* <https://github.com/EmbarkStudios/rust-ecosystem/issues/18>

I say scare quote tracking because due to the nature of console NDAs it's unlikely you'll see much if any useful details in an open public forum.

The issues aren't dissimilar to those facing Godot (although it has the benefit it's able to use existing C++ compilers) and the project has previously outlined some of the issues involved:

* <https://docs.godotengine.org/en/4.0/tutorials/platform/conso...>

* <https://godotengine.org/article/godot-consoles-all-you-need-...>

The current "solution" seems to be console-related development activity occurring via the recently established W4 Games (https://w4games.com/2023/02/28/godot-support-for-consoles-is...) but that's obviously never going to be openly developed without console platform approval (same as any other game engine).

Some companies are betting on Rust, like Embark Studio (though I'm not sure their next big game, ARC Raiders, is actually fully based on Rust... but it will come !)

Next generation uses Rust https://github.com/EmbarkStudios/rust-ecosystem

Record patterns are one step on the path to general pattern matching utility. The bigger building block is general deconstructors. I recommend reading Functional Transformation of Immutable Objects by Brian Goetz. The idea of "withers" shown there requires deconstructors:

https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...

This is the vague plan.

You may be joking but...

Here is the much more detailed version: https://github.com/openjdk/amber-docs/blob/master/eg-drafts/reconstruction-records-and-classes.md

This kind of pattern matching is discussed in the design notes: https://github.com/openjdk/amber-docs/blob/master/site/design-notes/patterns/pattern-match-object-model.md

True, but that only pushes the question of value down the line.

I'm curious about lenses because Java did have a serious problem that required a solution: working with "simple" data correctly was difficult. The chosen solution was ADTs, so we did buy into that. But the approach being explored for transforming records (https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...) only works one level at a time rather than for an entire path. So I wonder how valuable it would be to have a solution for paths. If the answer is that it's mostly valuable for an approach we haven't bought into yet, then we might not need to consider it just yet.

Just a heads up, something like that spread operator is actually coming sooner or later to java: https://github.com/openjdk/amber-docs/blob/master/eg-drafts/...

Pattern matching (for records) is already a preview feature.