Expresión lambda para niños

Una expresión lambda, también conocida como función anónima, es como una pequeña pieza de código que hace un trabajo específico, pero que no tiene un nombre. Imagina que necesitas una herramienta para una sola tarea rápida; en lugar de darle un nombre y guardarla en tu caja de herramientas, simplemente la usas y listo.

Estas funciones sin nombre son muy útiles en la programación. A menudo se usan como "ingredientes" que se pasan a otras funciones más grandes, o para crear el resultado de una función que necesita devolver otra función. Si una tarea se va a hacer solo una o pocas veces, usar una expresión lambda puede ser más sencillo que escribir una función completa con su propio nombre.

Las funciones lambda son muy comunes en lenguajes de programación que tratan las funciones como "objetos" que se pueden pasar y usar como cualquier otro dato. Su idea original viene del trabajo de un matemático llamado Alonzo Church en 1936, mucho antes de que existieran las computadoras modernas.

Las funciones anónimas han sido parte de los lenguajes de programación desde que se creó Lisp en 1958, y cada vez más lenguajes las incluyen.

¿Para qué sirven las expresiones lambda?

Las expresiones lambda se usan para tareas rápidas que no necesitan un nombre especial. Piensa en ellas como notas rápidas que escribes para un cálculo o una acción específica, sin necesidad de un título.

Usar expresiones lambda es una cuestión de estilo. Cada expresión lambda podría ser reemplazada por una función con nombre. Sin embargo, muchos programadores las prefieren para mantener el código más limpio, evitando tener muchas funciones pequeñas con nombres que solo se usan una vez.

En algunos lenguajes, las expresiones lambda se usan para cosas como conectar acciones a eventos (por ejemplo, qué pasa cuando haces clic en un botón) o para crear funciones personalizadas de forma más eficiente y fácil de leer.

Organizar y clasificar datos

Cuando necesitas ordenar una lista de cosas de una manera especial, las expresiones lambda pueden ser muy útiles. En lugar de crear una función completa solo para esa comparación, puedes usar una lambda.

La mayoría de los lenguajes de programación tienen una función para ordenar listas. Esta función a menudo puede recibir otra función que le dice cómo comparar dos elementos.

Por ejemplo, si tienes una lista de palabras y quieres ordenarlas por su longitud (cuántas letras tienen):

>>> a = ['casa', 'automóvil', 'avión']
>>> a.sort(lambda x,y: cmp(len(x), len(y)))
>>> print(a)
['casa', 'avión', 'automóvil']

Aquí, la expresión lambda `lambda x,y: cmp(len(x), len(y))` es la que le dice a la función `sort` cómo comparar las palabras: compara la longitud de `x` con la longitud de `y`.

Funciones que "recuerdan" (Clausuras)

Las clausuras son funciones que "recuerdan" el entorno donde fueron creadas, lo que significa que pueden usar variables de ese entorno incluso después de que el entorno original ya no exista. Una expresión lambda puede ser una clausura.

Imagina que quieres crear funciones que comprueben si un número es menor que un cierto "límite".

def crear_comparador(limite):
    return lambda x: x < limite

>>> es_menor_que_10 = crear_comparador(10)
>>> es_menor_que_20 = crear_comparador(20)

>>> print es_menor_que_10(5), es_menor_que_10(8), es_menor_que_10(13), es_menor_que_10(21)
True True False False

>>> print es_menor_que_20(5), es_menor_que_20(8), es_menor_que_20(13), es_menor_que_21(21)
True True True False

En este ejemplo, `crear_comparador` devuelve una función lambda. Esa lambda "recuerda" el valor de `limite` que se le pasó cuando fue creada.

Funciones de orden superior

Algunos lenguajes de programación tienen funciones especiales que pueden tomar otras funciones (incluidas las lambdas) como argumentos. Esto se llama "funciones de orden superior".

Mapeo

La función de mapeo aplica una operación a cada elemento de una lista y crea una nueva lista con los resultados.

Por ejemplo, para calcular el cuadrado de cada número en una lista:

>>> a = [1, 2, 3, 4, 5, 6]
>>> print map(lambda x: x*x, a)
[1, 4, 9, 16, 25, 36]

La lambda `lambda x: x*x` se aplica a cada número de la lista `a`.

Filtro

La función de filtro selecciona elementos de una lista que cumplen una condición específica.

Por ejemplo, para obtener solo los números pares de una lista:

>>> a = [1, 2, 3, 4, 5, 6]
>>> print filter(lambda x: x % 2 == 0, a)
[2, 4, 6]

La lambda `lambda x: x % 2 == 0` comprueba si un número es par.

Doblar (Reducir)

La función de doblar (o reducir) combina todos los elementos de una lista en un solo valor, aplicando una operación repetidamente.

Por ejemplo, para multiplicar todos los números de una lista:

>>> a = [1, 2, 3, 4, 5]
>>> print reduce(lambda x,y: x*y, a)
120

La lambda `lambda x,y: x*y` multiplica los dos argumentos, acumulando el resultado.

Lenguajes de programación que las usan

Muchos lenguajes de programación modernos soportan las funciones anónimas o expresiones lambda. Algunos de los más populares incluyen:

• C#
• C++ (desde la versión C++11)
• Dart
• Elixir
• Go
• Haskell
• Java (desde Java 8)
• JavaScript
• Julia
• Lisp
• Lua
• MATLAB
• OCaml
• Perl
• PHP (desde PHP 5.3)
• Python
• R
• Ruby
• Scala
• Smalltalk
• Swift
• TypeScript
• Visual Basic .NET

Generalmente, los lenguajes que permiten tratar las funciones como cualquier otro tipo de dato (como números o texto) suelen tener soporte para funciones anónimas.

Ejemplos de expresiones lambda

Veamos cómo se ven las expresiones lambda en algunos lenguajes de programación populares.

C++ (desde C++11)

En C++, las expresiones lambda se ven así:

[captura](parámetros) -> tipo_de_retorno { cuerpo_de_la_función }

La parte `[captura]` es especial: permite que la lambda "capture" variables del entorno donde fue creada. Por ejemplo, una lambda que suma dos números:

[](int x, int y) -> int { return x + y; }

Si quieres que una lambda use una variable de fuera, puedes "capturarla":

std::vector<int> mi_lista{ 1, 2, 3, 4, 5 };
int total = 0;
// Esta lambda suma cada número de la lista a 'total'
std::for_each(begin(mi_lista), end(mi_lista), [&total](int x) {
        total += x;
});

Aquí, `[&total]` significa que la lambda puede modificar la variable `total` que está fuera de ella.

JavaScript

JavaScript permite usar funciones anónimas de varias maneras. Una forma común es:

alert((function(x){
        return x*x;
})(10)); // Esto mostrará 100

Desde una versión más reciente (ES6), hay una forma más corta, llamada "función de flecha":

alert((x => x*x)(10)); // Esto también mostrará 100

Estas funciones son muy usadas en la web para hacer cosas rápidas, como cambiar el título de una página:

javascript:(function(){document.title=location.href;})();

Este código cambia el título de la pestaña del navegador a la dirección web actual.

Java (desde Java 8)

En Java, las expresiones lambda se llaman "Expresiones Lambda" y se introdujeron en la versión 8. Tienen esta forma:

(parámetros) -> cuerpo_de_la_función

Por ejemplo, una lambda que suma dos números:

(a, b) -> a + b

O una que imprime un mensaje:

// sin parámetros
() -> System.out.println("Hola, mundo.")

Las lambdas en Java se usan con algo llamado "interfaces funcionales", que son como contratos para funciones.

Python

Python soporta funciones anónimas simples con la palabra clave `lambda`. Sin embargo, el cuerpo de una lambda en Python debe ser una sola expresión (no puede tener varias líneas de código o declaraciones complejas).

>>> cuadrado = lambda x: x*x
>>> print(cuadrado(10))
100

Aunque Python tiene lambdas, es más común y recomendado usar funciones normales con nombre para tareas más complejas, incluso si solo se usan una vez, porque son más flexibles.

Véase también

En inglés: Anonymous function Facts for Kids