Closures em Java - Qual versão escolher?

Assuntos Gerais Notícias
#1

Ola Bini, um dos responsáveis pelo blog de Java da editora APress comentou sobre as duas propostas para a implementação de closures na linguagem Java e os problemas que cada uma delas pode trazer (ou resolver) caso sejam adicionadas:

Texto completo: The Future of Java Closures

Se eu tivesse que escolher, não colocaria nenhuma das duas, não acho que a sintaxe do Java aguente mais uma puxada grande como essa, além do que, a maioria das bibliotecas básicas da linguagem foi escrita sem isso e vai contunuiar funcionando assim.

E o que é que você acha disso tudo?

#2

A turma quente do Java 5 (Neal Gafter, Gilad Bracha, Peter van der Ahé, e honorariamente o James Gosling) postou mais uma versão (simplificada, dessa vez) da proposta para Closures.

Eu ainda sou mais a favor da proposta do Gafter, mas as outras parecem ser mais simples.

#3

Não custa também ler essa entrevista com o Neal Gafter. Ele explica o propósito por trás das closures:
http://www.artima.com/lejava/articles/neal_gafter_closures.html

#4

Vou postar abaixo um exemplo (que obviamente não compila) do que seria possível com a proposta BGGA (Bracha, Gafter, Gosling, Ahé).

Uma coisa que incomoda no começo, mas a que você se acostuma depois, é que você tem de usar “invoke” explicitamente, em vez de usar uma closure como se fosse um nome de função.

import java.util.*;

class Cliente {
    private String nome; 
    private int id;
    public String getNome() ... bla bla bla ...
}


class TesteClosures {
    /**
    * Function composition, like Haskell's operator "."
    * f . g (x) is equivalent to f (g (x))
    * @param f the first function
    * @param g the second function
    * @return An instance of a function that is the composition of f and g.    
    */
    public static {double =&gt double} compose (
        {double =&gt double} f, 
        {double =&gt double} g) {
        return new {double =&gt double} () {
            double invoke (double x) {
                return f.invoke (g.invoke (x));
            }
        }
    }
    /**
    * Sample of "compose"
    */
    private {double =&gt double} sin = {double x =&gt Math.sin(x); }
    private {double =&gt double} sqrt = {double x =&gt Math.sqrt(x); }
    private {double =&gt double} sinsqrt = compose (sin, sqrt);
    private {double =&gt double} abscos = compose (
        { x =&gt Math.abs(x); }, { y =&gt Math.abs (y); });
    

    public static void main(String[] args) {
        List<Cliente> clientes = new ArrayList<Cliente>();
        //-- Composição de funções
        
        
        //-- Ordenando com "closures"
        {Cliente,Cliente=&gtint} ordemCrescente = { Cliente c1, Cliente c2 =&gt 
            int ret = c1.getNome().compareTo(c2.getNome());
            if (ret != 0) return ret;
            return c1.getId() - c2.getId();
        };
        {Cliente,Cliente=&gtint} ordemDecrescente = { Cliente c1, Cliente c2 =&gt 
            return -ordemCrescente.invoke(c1, c2);
        };
        // ordem crescente
        clientes.sort (ordemCrescente);
        // ordem decrescente
        clientes.sort (ordemDecrescente);
        
        //-- Usando um comparator tradicional e inner classes
        // ordem crescente
        clientes.sort (new Comparator<Cliente>() {
            public int compare(Cliente c1, Cliente c2) {
                int ret = c1.getNome().compareTo(c2.getNome());
                if (ret != 0) return ret;
                return c1.getId() - c2.getId();
            }
        }
        // ordem decrescente
        clientes.sort (new Comparator<Cliente>() {
            public int compare(Cliente c1, Cliente c2) {
                int ret = c1.getNome().compareTo(c2.getNome());
                if (ret != 0) return - ret;
                return c2.getId() - c1.getId();
            }
        }
    }
}
#5