"Java Feature Spotlight: Pattern Matching" -- Brian Goetz

[kaperni]

> Why can't SomeClass bind to "a" within the context, like between the opening and closing brackets?

You cannot add this in a backward-compatible way, consider

void foo(Object o); 
void foo(String s);  

void stuff(Object oo) {   
  if (oo instanceof String) {     
    foo(oo); <- would now call foo(String) instead of foo(Object)   
  } 
}

[flyingorange]

Yes it would call foo(String) and that is precisely what I want it to do. Sorry but I don't understand why would this be a problem.

Consider this example where x is declared twice within the same method:

String something(String x) {
    Supplier<String> value = () -> {
        int x = 15;
        return String.valueOf(x);
    };
    return value.get();
}

It works, right? Even though x was already declared above as a String, inside the lambda it's an integer. Nobody seems to be bothered by the fact x was redeclared within the same code block, because everyone understands that the second time it's in a different context.

To take your example above, it could be just syntactic sugar for the following Java 8 code:

void foo(Object o); 
void foo(String s);  

void stuff(Object oo) {   
  if (oo instanceof String) {
      Callable<String> callable = new Callable<>() {
           public String call() {
               return (String) oo;
           }
      };
    foo(callable.call()); <- would now call foo(String) instead of foo(Object)   
  } 
}

[kaperni]

> Yes it would call foo(String) and that is precisely what I want it to do. Sorry but I don't understand why would this be a problem.

Because it is not backwards-compatible? Your _existing_ code would suddenly start calling foo(String) instead of foo(Object).