Uma expressão lambda é uma função sem nome, que pra ser utilizada precisa ser atribuída à uma variável, que é invocada como se fosse a função. A vantagem em usá-las é poder transportar pequenas funções como valores.
No Javascript, as lambdas são definidas utilizando o function, mas é possível criar funções anônimas sem essa indicação, usando o =>, por isso são também chamadas de arrow functions. A invocação é feita usando a variável atribuída com parênteses e seus parâmetros (caso existam). Veja um exemplo logo abaixo:
var mens = function() {
document.write("Expressão Lambda!<br/>");
};
var soma = function(num1, num2) {
return num1 + num2;
};
mens(); // Exibindo lambda tipo void.
document.write(soma(10, 5)); // Exibindo lambda tipo int
Versão simplificada:
var mens = () => document.write("Expressão Lambda!<br/>");
var soma = (num1, num2) => num1 + num2; // Note que indicar retorno é desnecessário
mens(); // Exibindo lambda tipo void.
document.write(soma(10, 5)); // Exibindo lambda tipo int
As declarações de funções anônimas em PHP, também utilizam function, de forma parecida com Javascript, e a invocação é feita com a variável atribuída (incluindo o cifrão) e os parênteses e parâmetros, caso existam. Veja como é feito logo abaixo:
$mens = function(){echo "Expressão Lambda!<br/>";};
$soma = function($num1, $num2){return $num1 + $num2;};
$mens(); // Exibindo lambda tipo void.
echo $soma(10, 5); // Exibindo lambda tipo int
No Java, isso já é um pouco diferente, ao atribuir uma variável à uma expressão lambda, estamos implementando o método void run() da interface Runnable (padrão do Java), e por isso, para invocar é necessário colocar o run() após a variável. No caso de métodos que retornam valores e/ou recebam parâmetros, criamos dentro da classe, uma interface privada com apenas a assinatura de um método (interface funcional) com o tipo de retorno que queremos pegar, e dentro do main, declaramos o tipo da variável com o nome dessa interface criada. Veja abaixo como se usa:
@FunctionalInterface
private interface Valores { // Interface com função abstrata pra retornar um valor.
int resul(int n1, int n2);
}
public static void main(String[] args) {
Runnable mens = () -> {
System.out.println("Expressão Lambda!");
};
Valores soma = (int num1, int num2) -> {
return num1 + num2;
};
mens.run(); // Exibindo lambda tipo void.
System.out.println(soma.resul(10, 5)); // Exibindo lambda tipo int
}
Simplificando ainda mais:
@FunctionalInterface
private interface Valores { // Interface com função abstrata pra retornar um valor.
int resul(int n1, int n2);
}
public static void main(String[] args) {
Runnable mens = () -> System.out.println("Expressão Lambda!");
Valores soma = (num1, num2) -> num1 + num2; // Note que indicar retorno e tipos é desnecessário
mens.run(); // Exibindo lambda tipo void.
System.out.println(soma.resul(10, 5)); // Exibindo lambda tipo int
}
No caso do C++, as expressões lambda são definidas com dois colchetes, os parênteses com ou sem parâmetros, e o corpo do código dentro das chaves. Atribuímos uma lambda à uma variável do tipo auto (que identifica automaticamente o tipo dela, mas não a torna dinâmica), e esta é exibida com os parênteses e seus parâmetros, caso existam. Se existir algum retorno, o tipo dele é indicado pela seta antes do bloco. Veja como se usa logo abaixo:
auto mens = [](){cout << "Expressão Lambda!" << endl;};
auto soma = [](int num1, int num2)->int {return num1 + num2;};
mens(); // Exibindo lambda tipo void.
cout << soma(10, 5) << endl; // Exibindo lambda tipo int
Em Python, as expressões anônimas são identificadas apenas escrevendo lambda, dispensando o uso de parênteses, caso existam parâmetros, eles são indicados após a palavra e antes dos dois pontos, separados por vírgula, caso existam mais de um. Apenas a invocação dos métodos necessita ter os parênteses e os parâmetros, se existirem. Veja um exemplo logo abaixo:
mens = lambda: print("Expressão Lambda")
soma = lambda num1, num2: num1 + num2 # Note que indicar retorno é desnecessário
mens() # Exibindo lambda tipo void
print(soma(10, 5)) # Exibindo lambda tipo int
No C#, basta colocarmos os parênteses e os comandos para lambdas void e sem parâmetros, caso necessite usar uma expressão com retorno e/ou com parâmetros, crie um método abstrato dentro da classe com delegate antes do tipo:
delegate int resul(int num1, int num2); // Método abstrato que retornará um valor
static void Main(string[] args) {
Action mens = () => Console.WriteLine("Expressão Lambda!");
resul soma = (num1, num2) => num1 + num2; // Note que indicar retorno e tipos é desnecessário
mens(); // Exibindo lambda tipo void
Console.WriteLine(soma(10, 5)); // Exibindo lambda tipo int
}