Pattern matching improvements

[Olexandr Rotan]

I would like to say that, imo, point that list (or any sequential
collection/array) patterns make code readable is a really brave assumption
to say the least. I had some experience reading code like this in C#, and
to say that I was not impressed would be an understatement. For me, it
gives off strong regex vibes, which are, meanwhile really powerful tool,
known to be barely readable.
Also example you have provided above seems kind of python-like in a way
that in which situation would you expect List OR single object as input.
Unless there are union types (which I'm also not a fan of to be fair), your
example is not from the java world, in my opinion.
The more realistic applixation for such patterns is match "shape" of
collection, if you already know you are dealing with collection, but I'm
not sure that game worth the candle to be fair. I guess such patterns could
be more effective then traditional ways to do things that they are intended
to substitute, so maybe in some caseslike data-oriented programming
performance improvements could be significant, but besides I would think
ten times before introducing another regex into the language.

On Wed, May 29, 2024, 16:02 Brian Goetz <brian.goetz at oracle.com> wrote:

> We take inspiration from many sources, including many existing languages
> that have pattern matching.
>
> I think what you’re asking is: “have you considered List patterns”.  And
> indeed, we have.  List patterns are the dual to list literals (more
> generally, collection patterns are the dual to collection literals); we
> would consider introducing collection patterns when we are able to treat
> them holistically with collection literals.  However, of all the pattern
> matching features one could craft “have you considered X” for, list
> patterns are among the weakest, and so these are likely to be lower
> priority than other pattern matching features in the pipeline (e.g.,
> varargs patterns, constant patterns, etc.).
>
> On May 29, 2024, at 7:58 AM, Georgi Stoyanov <gstoyanov at live.com> wrote:
>
> Hey folks,
> I'm really excited about the new Java features that keep getting added,
> and I had an idea I wanted to share. Have you thought about introducing a
> pattern matching feature similar to Scala’s, which allows for more concise
> and readable code?
> In Scala, you can match a list that starts with a specific element without
> having to spell everything out. For example:
> case List(_, 2, _*) => "I only care that this list has 2 as the second
> element"
> case Person("Alice", age) => "It's Alice"
>
> This approach makes the code less verbose and lets you focus directly on
> the elements you care about. It’s a lot cleaner than extracting elements
> and comparing them separately, which is what we do now in Java.
> I think adding something like this to Java would be a big win, making
> pattern matching more powerful and the code more readable.
> Just wanted to throw this idea out there and see what you all think.
>
> Kind Regards,
> Georgi Stoyanov
>
>
>
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-dev/attachments/20240529/62452be7/attachment.htm>