Support for java 11 syntax

Gallery
7

i not know what you referred to,
download / unzip / make shortcut to desktop

run your test ( and sysinfo )
( works on Win 10 )

@FunctionalInterface
interface MyFunction{
  float calculate(float x);
}

void setup(){
  MyFunction doubling = (float x)-> x * 2;
  var doubled = new float[]{2,3};
  for (var value:doubled){
    println(doubling.calculate(value));
  }
  mysysinfo();
}

void mysysinfo() {
  println("\nsysinfo:");
  println( "System     : " + System.getProperty("os.name") + "  " + System.getProperty("os.version") + "  " + System.getProperty("os.arch") );
  println( "JAVA       : " + System.getProperty("java.home")  + " rev: " +javaVersionName);
  //println( "\n" + isGL() + "\n" );
  println("OPENGL_VENDOR: " + PGraphicsOpenGL.OPENGL_VENDOR+" OPENGL_RENDERER: " + PGraphicsOpenGL.OPENGL_RENDERER+" OPENGL_VERSION: " + PGraphicsOpenGL.OPENGL_VERSION+" GLSL_VERSION: " + PGraphicsOpenGL.GLSL_VERSION);
  println( "user.home  : " + System.getProperty("user.home") );
  println( "user.dir   : " + System.getProperty("user.dir") );
  println( "sketchPath : " + sketchPath() );
  println( "dataPath   : " + dataPath("") );
  println( "dataFile   : " + dataFile("") );
}

and ( your test VAR code ) only run in this latest downloaded version,
but i fail to find where the file differences are
AND he fail to have any version info ( as file or in run window “Processing 0270” same )

also not understand, is he there now? can we call it:

Processing 4.0 beta

my first test run on both ( ? as not use the var thing ?)

// https://www.datadrivenempathy.com/processing

/*

 About Sam Pottinger's Processing Branch
 The Sam Pottinger branch of Processing offers the following over the mainline version of Processing:
 
 Support for Java 11, OpenJDK, and OpenJFX.
 Move to ANTLR 4 with Java 8 language features (lambdas and generics!) and localization of syntax errors.
 Continuous integration and deployment via Travis.
 Updated license text.
 
 It is an incredibly exciting step forward in the Processing code base that helps the project prepare for its future
 while migrating to a fully open source stack and giving the community long-awaited access to important language features
 like lambdas and generics. It is currently being reviewed so is not yet official build from the Processing foundation and its edits are not accepted.
 However, like regular Processing, it is released under the same GPL / LGPL license (use at your own risk,
 no implied or explicit warranty of any kind).
 
 */

// also see https://discourse.processing.org/t/arraylist-full-of-functions/10786/6

// generic example from
// https://www.tutorialspoint.com/java/java_generics.htm#
// now try the new thing:

public static < E > void printArray( E[] inputArray ) {
  for (E element : inputArray)  System.out.printf("%s, ", element);
  println();
}

Integer[]   intArray    = { 1, 2, 3, 4, 5 };
Double[]    doubleArray = { 1.1d, 2.2d, 3.3d, 4.4d };
Character[] charArray   = { 'H', 'E', 'L', 'L', 'O' };

void setup() {
  println("Array intArray contains:");
  printArray(intArray);   // pass an Integer array

  println("\nArray doubleArray contains:");
  printArray(doubleArray);   // pass a float array

  println("\nArray charArray contains:");
  printArray(charArray);   // pass a Character array
  
  println("_____________\ntest also LAMBDA example\n");
  use_lambda();
}

void draw(){}

// now check on
// https://www.geeksforgeeks.org/lambda-expressions-java-8/

interface FuncInterface {
  void abstractFun(int x);               // An abstract function
  default void normalFun() {
    println("default normalFun(): Hello from interface FuncInterface");     // A non-abstract (or default) function
  }
}

void use_lambda() {     // lambda expression to implement above functional interface.
  //                       This interface by default implements abstractFun()
  FuncInterface fobj = (int x)->println("x= "+x+", 2*x= "+2*x);
  fobj.abstractFun(5);  // This calls above lambda expression and prints 10.
  fobj.normalFun();     // prints info
}

/*
 //without the Generic Methode it produce:
 
 Array intArray contains:
 [0] 1
 [1] 2
 [2] 3
 [3] 4
 [4] 5
 
 Array doubleArray contains:
 [0] 1.1
 [1] 2.2
 [2] 3.3
 [3] 4.4
 
 Array charArray contains:
 [0] H
 [1] E
 [2] L
 [3] L
 [4] O
 
 // with:
 
 Array intArray contains:
 1, 2, 3, 4, 5,
 
 Array doubleArray contains:
 1.1, 2.2, 3.3, 4.4,
 
 Array charArray contains:
 H, E, L, L, O,
 
 _____________
test also LAMBDA example

x= 5, 2*x= 10
default normalFun(): Hello from interface FuncInterface
 */