Amber features 2026

[Brian Goetz]

While I totally understand why you would want to do that, I don't see 
the connection between pattern assignment and extending the type system 
to permit denotation of quantified or existential types?  I don't see 
any patterns in your example, only type manipulation.

What you're saying is that you'd like a conversion from Foo<?> to 
`\exist T .
Foo<T>`.  This is understandable, as wildcards are basically 
existentials already, and is just as safe as the the trick of calling an 
out-of-line generic method.

But I just don't see the connection with pattern assignment?  It seems 
like what you really want is "generic variables", to go along with 
generic methods and classes?




On 1/13/2026 5:56 PM, Archie Cobbs wrote:
> [ This is in reply to 
> https://mail.openjdk.org/pipermail/amber-spec-experts/2026-January/004306.html 
> on amber-spec-experts. ]
>
> Hi Gavin,
>
> The "Pattern Assignment" and "Constant Patterns" ideas sound good to 
> me. The "Pattern Assignment" idea is a natural way to extend pattern 
> matching, which is motivated by the frequent need to declare variables 
> to access the "variable components" in an instance of some object type.
>
> My question is: Wouldn't the same motivation apply to generic type 
> parameters as well?
>
> Here's a trivial example. Suppose we have this class:
>
>     public record Property<T>(T value) {
>         boolean has(T t) {
>             return t == value;
>         }
>     }
>
> and we want to write a method to check that a list of Property's are 
> well-behaved.
>
> Here's what we'd LIKE to do, which is use "Pattern Assignment" for the 
> generic type variable:
>
>     public void verifyHas(List<Property<?>> properties) {
>         for (Property<?> element : properties) {
> <T> Property<T> property = element;
>             T value = property.value();
>             assert property.has(value);  // no cast needed here!
>         }
>     }
>
> but here's what we HAVE to do today to avoid the unchecked cast:
>
>     public void verifyHas(List<Property<?>> properties) {
>         for (Property<?> property : properties) {
>             verifyHas(property);
>         }
>     }
>
>     // Ugh. This method exists solely to declare <T> so we can avoid 
> an unchecked cast
>     private <T> void verifyHas(Property<T> property) {
>         T value = property.value();
>         assert property.has(value);
>     }
>
> If we're going to add "Pattern Assignment" it seems like it would be 
> reasonable for generic type variables to also benefit.
>
> Cheers,
> -Archie
>
> -- 
> Archie L. Cobbs
-------------- next part --------------
An HTML attachment was scrubbed...
URL: <https://mail.openjdk.org/pipermail/amber-dev/attachments/20260113/629ccb47/attachment-0001.htm>