Array patterns (and varargs patterns)

[John Rose]

On 7 Jan 2021, at 6:18, Brian Goetz wrote:

> …Varargs patterns will build on it (as shown in the mail); if and 
> when Java ever gets collection literals, there will be corresponding 
> collection patterns too.  I think the path to streamlining this is 
> not to try and simplify the syntax of the primitive, but move upwards 
> to higher-level patterns.

OTOH if patterns (like `switch ((O)x) case P v:` or `let P v = (O)x`) 
are the duals of assignment (like `x = v` or `O x = v`), then we are 
within our moral rights to make a pattern dualization of the venerable 
Java syntax `T[] x = {a,b,c}`, which is sugar for `T[] x = new 
T[]{a,b,c}`.  The sugar allows you to take the second `T[]` (and the 
`new`) for a typeful context (`T[] x`).

So without the sugar we get something like:

T[] a = …;
switch (a) { case new T[]{a,b,c}: }

(The `new` from `new T[]{a,b,c}` is dropped because `new` doesn’t 
appear in patterns.)

But with the same sugar, but dualized, we get:

T[] a = …;
switch (a) { case {a,b,c}: }

In other words, when the pattern target is already an array, there is no 
need for the ceremony of repeating the array type, as with normal array 
declarations.

Likewise:

T[][] a2d = …;
switch (a2d) { case {{a,b},{c,d}}: }

I think this is what Tagir expected, and I think it is a reasonable 
“penciling out” of the basic moves of the game we are playing here.

Moving on to varargs, the context of a method call marked varargs allows 
elision not only of the `new T[]` in `new T[]{a,b,c}` but also the 
braces, you you can equally say `f(a,b,c)` or `f(new T[]{a,b,c})`.

(But not `f({a,b,c})`.  So, we don’t get `f2d({{a,b},{c,d}})` by 
analogy with nested array initializers.  Whatever.)

If a pattern-method can take a pattern-flavored argument, and perhaps a 
varargs argument to boot, it’s pretty clear that additional moves 
could follow quickly:

pattern f(pattern T[] a} { … }
pattern f2d(pattern T[][] a) { … }
pattern fv(pattern T a…) { … }
// extra “pattern” keyword on parameters for emphasis…

switch (x) {
   case f({a,b,c}): …   // omit `new T[]` b/c type
   case f2d({{d,e,f},{g}}): …   // omit `new T[][]` b/c type
   case fv(h,i,j,k): …   // omit `new T[]` and braces b/c varargs
}

-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-spec-observers/attachments/20220907/380e9fad/attachment.htm>