Verso Java 7: lambda expressions e closures

Con l’arrivo di Dolphin si conclude quello che è stato uno dei dibattiti più accesi degli ultimi tempi nella comunità  Java, ossia l’introduzione di funzioni lambda (lambda expressions) e chiusure (closures), fino ad ora solo in parte simulabili e riproducibili con i costrutti disponibili (ad esempio le classi anonime): il sottoprogetto incaricato di implementare questa feature già  da tempo presente in linguaggi quali Ruby o Python è Project Lambda.

Tutte le lambda expression saranno introdotte dalla keyword #; in particolare, la sintassi prevista sarà : #(argomenti)(espressione) o #(argomenti){blocco di istruzioni}.

Esempi di lambda expression sono quindi #()(42), semplice funzione senza argomenti che non fa altro che ritornare 42, oppure #(int x, int y)(x * y), funzione che prende in input due interi e ritorna il loro prodotto.

Possiamo anche assegnare una funzione ad una variabile:

#int() fortyTwo = #()(42);
#int(int) doubler = #(int x)(x + x);
#int(int,int) multiplier = #(int x, int y)(x * y);

…e passare una funzione come argomento ad un metodo:

public int[] map(int[] a, #int(int) fn) {
  int[] b = new int[a.length];
  for (int i = 0; i < a.length; i++)
    b[i] = fn(a[i]);
  return b;
}

àˆ facile notare come in determinate circostanze il codice risulti scritto in maniera molto più compatta, ad esempio osserviamo l’invocazione di un ordinamento definito ad hoc su una collection. Fino ad ora:

List<String> data = ...;
Collections.sort(data,
                 new Comparator<String>() {
                   public int compare(String a, String b) {
                     return a.length() - b.length();
                   }
                 });

Con le lambda expressions:

Collections.sort(data,
          #(String a, String b)(a.length() - b.length()));

àˆ infine possibile creare delle chiusure (closures), funzioni-oggetto in grado di “catturare” variabili. Ad esempio

public #int(int) adder(int x){ return #(int y)(x + y); }

è un metodo che ritorna una funzione. Invocare adder(42) ritorna quindi una funzione che aggiungerà  42 all’argomento su cui verrà  invocata, quindi:

#int(int) a42 = adder(42);
assert a42(0) == 42;

Ulteriori approfondimenti sul sito di Project Lambda.

Soddisfatti di questa nuova feature o preferivate che le lambda expressions rimanessero appannaggio di altri linguaggi?