Métodos anônimos/Closures

(a) => { stdout.printf("%d\n", a); }

Um método anônimo, támbem conhecido como uma expressão lambda, função literal ou closure, pode ser definida em Vala com o operador => . A lista de parâmetros fica a esquerda do operador, e o escopo do método à direita.

Um método anônimo por si só como como acima não faz muito sentido. Ele só é útil se designado diretamente a váriavel de um tipo delegado ou passado como um argumento à outro método.

Tenha em mente que nem o parâmetro nem o tipo de retorno é informado explicitamente. Invés disso os tipos são inferidos pela assinatura da delegação usada.

Atribuindo um método anônimo para uma variável delegada:

delegate void PrintIntFunc(int a);

void main() {
    PrintIntFunc p1 = (a) => { stdout.printf("%d\n", a); };
    p1(10);

    // Chaves são opcionais se o corpo conter só uma declaração:
    PrintIntFunc p2 = (a) => stdout.printf("%d\n", a);
    p2(20);
}

Passando um método anônimo para outro método:

delegate int Comparator(int a, int b);

void my_sorting_algorithm(int[] data, Comparator compare) {
    // ... 'compare' é chamado em algum lugar aqui ...
}

void main() {
    int[] data = { 3, 9, 2, 7, 5 };
    // Um método anônimo é passado como um segundo argumento:
    my_sorting_algorithm(data, (a, b) => {
        if (a < b) return -1;
        if (a > b) return 1;
        return 0;
    });
}

Métodos anônimos são closures) reais. Isso significa que você pode acessar variáveis locais de um método exterior dentro da expressão lambda:

delegate int IntOperation(int i);

IntOperation curried_add(int a) {
    return (b) => a + b;  // 'a' é uma váriavel externa
}

void main() {
    stdout.printf("2 + 4 = %d\n", curried_add(2)(4));
}

Nesse de adição com currying(veja Currying) retorna um método recém criado que preserva o valor de a. Esse método retornado é chamado diretamente depois com 4 como argumento resultante na soma de dois números.