From 287c609201a6f51742cb1b36ef809a2965e7e850 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Wed, 2 Sep 2026 16:15:30 -0700 Subject: [PATCH 1/9] =?UTF-8?q?Create=20Funciones=5Fan=C3=B3nimas=5Fexpres?= =?UTF-8?q?iones=5Flambda?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "research/Funciones_an\303\263nimas_expresiones_lambda" | 1 + 1 file changed, 1 insertion(+) create mode 100644 "research/Funciones_an\303\263nimas_expresiones_lambda" diff --git "a/research/Funciones_an\303\263nimas_expresiones_lambda" "b/research/Funciones_an\303\263nimas_expresiones_lambda" new file mode 100644 index 0000000..8b13789 --- /dev/null +++ "b/research/Funciones_an\303\263nimas_expresiones_lambda" @@ -0,0 +1 @@ + From c5a5f51a3943a60a43f8c10ce9cce43ccc026ee7 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:51:22 -0700 Subject: [PATCH 2/9] =?UTF-8?q?Delete=20research/Funciones=5Fan=C3=B3nimas?= =?UTF-8?q?=5Fexpresiones=5Flambda?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- "research/Funciones_an\303\263nimas_expresiones_lambda" | 1 - 1 file changed, 1 deletion(-) delete mode 100644 "research/Funciones_an\303\263nimas_expresiones_lambda" diff --git "a/research/Funciones_an\303\263nimas_expresiones_lambda" "b/research/Funciones_an\303\263nimas_expresiones_lambda" deleted file mode 100644 index 8b13789..0000000 --- "a/research/Funciones_an\303\263nimas_expresiones_lambda" +++ /dev/null @@ -1 +0,0 @@ - From 30f57ac8da895830d6b44f5ff99f984442dc9b20 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:52:37 -0700 Subject: [PATCH 3/9] Create README.md --- .../Funciones-an\303\263nimas-y-expresiones-lambda/README.md" | 1 + 1 file changed, 1 insertion(+) create mode 100644 "research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" new file mode 100644 index 0000000..8b13789 --- /dev/null +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" @@ -0,0 +1 @@ + From 51bc473e21ba0f6aedb2bc7743158cb26d926777 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:55:55 -0700 Subject: [PATCH 4/9] Update README.md --- .../README.md" | 747 ++++++++++++++++++ 1 file changed, 747 insertions(+) diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" index 8b13789..cee5cef 100644 --- "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" @@ -1 +1,748 @@ +# Funciones Anónimas y Expresiones Lambda +## Introducción + +Las funciones anónimas y las expresiones lambda son mecanismos de los lenguajes de programación que permiten representar comportamiento como un valor que puede almacenarse, pasarse como argumento, devolverse desde otra función o utilizarse directamente dentro de una expresión. Su importancia está estrechamente relacionada con la programación funcional, las funciones de orden superior, los cierres léxicos (*closures*) y la composición de operaciones sobre colecciones. + +El concepto tiene una base teórica en el cálculo lambda, formalismo desarrollado por Alonzo Church en la década de 1930. El cálculo lambda proporciona una notación para definir funciones mediante abstracción y para aplicar funciones a argumentos; en los lenguajes modernos estas ideas aparecen, con diferentes reglas de tipos y ejecución, en características como las lambdas, funciones anónimas, funciones de primera clase y cierres [1], [2]. + +En la práctica, el concepto no es idéntico en todos los lenguajes. Python utiliza la forma `lambda parámetros: expresión` y la restringe a una sola expresión [3]. Java utiliza expresiones lambda asociadas a interfaces funcionales [4]. C# permite lambdas de expresión y de instrucciones, con conversión a delegados o árboles de expresión [5]. C++ construye un tipo de cierre sin nombre y dispone de un mecanismo explícito de captura de variables [6]. JavaScript ofrece expresiones `function` anónimas y funciones flecha, las cuales presentan diferencias semánticas importantes con respecto a las funciones tradicionales [7], [8]. Kotlin distingue entre *lambda literals* y declaraciones de funciones anónimas, aunque ambas representan funciones definidas en línea [9]. + +El objetivo de esta investigación es estudiar de manera integral las funciones anónimas y las expresiones lambda: su origen conceptual, sintaxis, semántica, alcance, captura de variables, funciones de orden superior, tipos, evaluación, usos prácticos, ventajas, limitaciones y diferencias entre varios lenguajes de programación modernos. + +--- + +# Desarrollo Técnico + +## 1. Fundamentos conceptuales + +Una función anónima es una función que se define sin asignarle un nombre propio en su declaración. Su utilidad aparece cuando el comportamiento es pequeño, local y solamente necesita utilizarse en un contexto concreto. + +Por ejemplo, una función tradicional puede definirse así: + +```python +def cuadrado(x): + return x * x +``` + +Mientras que una función anónima puede representarse como: + +```python +lambda x: x * x +``` + +La segunda forma no significa necesariamente que la función carezca de identidad en el entorno de ejecución. Significa que su definición no introduce un nombre de función explícito. Dependiendo del lenguaje, la función puede almacenarse posteriormente en una variable, pasarse como argumento o formar parte de un objeto de cierre. + +Una expresión lambda es una construcción sintáctica que permite expresar esa función de manera compacta. Su estructura conceptual puede representarse como: + +```text +(parámetros) -> cuerpo +``` + +La sintaxis exacta depende del lenguaje. Por ejemplo: + +| Lenguaje | Ejemplo | +| ---------- | ----------------------------- | +| Python | `lambda x: x * x` | +| Java | `(x) -> x * x` | +| C# | `x => x * x` | +| C++ | `[](int x) { return x * x; }` | +| JavaScript | `(x) => x * x` | +| Kotlin | `{ x -> x * x }` | + +Aunque estas construcciones son similares desde el punto de vista conceptual, no deben considerarse semánticamente idénticas. Cada lenguaje define sus propias reglas de tipos, captura de variables, retorno, contexto y representación interna [3]–[9]. + +--- + +## 2. Relación con el cálculo lambda + +El cálculo lambda constituye una de las bases formales de la teoría de lenguajes funcionales y de la noción de función como entidad manipulable. En su forma elemental aparecen tres operaciones fundamentales: + +* **Variable:** una referencia como `x`. +* **Abstracción:** una construcción equivalente a `λx.x + 1`. +* **Aplicación:** la utilización de una función sobre un argumento. + +Por ejemplo: + +```text +(λx. x + 1) 5 +``` + +representa la aplicación de una función anónima que suma uno a su argumento. El resultado es: + +```text +6 +``` + +La abstracción lambda no prescribe directamente una sintaxis concreta para lenguajes como Java, C++ o Python. Más bien proporciona una base conceptual para entender funciones como expresiones que pueden construirse y aplicarse [1], [2]. + +En los lenguajes actuales, esta idea se combina con sistemas de tipos, gestión de memoria, objetos, inferencia de tipos, excepciones, concurrencia y otras características que no forman parte del cálculo lambda puro. + +--- + +## 3. Funciones de primera clase + +Las lambdas adquieren especial utilidad cuando las funciones son tratadas como valores de primera clase. Esto significa, en términos generales, que una función puede: + +1. Almacenarse en una variable. +2. Pasarse como argumento. +3. Devolverse desde otra función. + +Un ejemplo conceptual es: + +```python +def aplicar(funcion, valor): + return funcion(valor) + + +doble = lambda x: x * 2 + +resultado = aplicar(doble, 10) + +print(resultado) +``` + +Resultado: + +```text +20 +``` + +La ventaja principal consiste en separar: + +* **qué operación se realiza**, de +* **sobre qué datos se aplica**. + +La función `aplicar()` no necesita conocer qué cálculo concreto representa `funcion`. + +Esta propiedad es fundamental para las llamadas **funciones de orden superior**, es decir, funciones que reciben otras funciones como argumentos, las devuelven como resultado o ambas cosas [1], [2]. + +--- + +## 4. Funciones de orden superior + +Las funciones de orden superior permiten construir operaciones genéricas sobre comportamiento. + +Un patrón frecuente es el filtrado de colecciones: + +```python +numeros = [1, 2, 3, 4, 5, 6] + +pares = list(filter(lambda x: x % 2 == 0, numeros)) + +print(pares) +``` + +Resultado: + +```text +[2, 4, 6] +``` + +La expresión lambda representa la condición de filtrado. Esto permite reutilizar `filter()` con diferentes criterios sin crear una función con nombre para cada caso. + +Otro ejemplo es la transformación: + +```python +numeros = [1, 2, 3, 4] + +cuadrados = list(map(lambda x: x * x, numeros)) + +print(cuadrados) +``` + +Resultado: + +```text +[1, 4, 9, 16] +``` + +También pueden utilizarse para ordenar objetos según una propiedad: + +```python +personas = [ + ("Ana", 25), + ("Luis", 19), + ("Pedro", 31) +] + +personas.sort(key=lambda persona: persona[1]) +``` + +La función lambda actúa como una política local de ordenamiento. Python documenta precisamente este tipo de uso al aceptar funciones pequeñas como argumentos de operaciones sobre colecciones [3]. + +--- + +## 5. Closures o cierres léxicos + +Una de las características más importantes asociadas a las funciones anónimas es la posibilidad de capturar variables del contexto en el que fueron creadas. + +Ejemplo: + +```python +def crear_incrementador(n): + return lambda x: x + n + + +sumar_10 = crear_incrementador(10) + +print(sumar_10(5)) +``` + +Resultado: + +```text +15 +``` + +La lambda utiliza `n`, aunque `n` pertenece al entorno de `crear_incrementador()`. + +La combinación entre una función y el entorno léxico que conserva las variables necesarias recibe el nombre de **closure** o **cierre**. La documentación de Python muestra este comportamiento mediante funciones lambda que recuerdan valores del ámbito que las contiene [3]. En C# se denomina igualmente *closure* a la combinación de una lambda con las variables que captura [5]. + +El concepto puede representarse así: + +```text + Entorno léxico + +------------------+ + | n = 10 | + +--------+---------+ + | + | captura + v + +------------------+ + | lambda x: x + n | + +--------+---------+ + | + v + suma(5) + | + v + 15 +``` + +Los cierres permiten implementar: + +* Fábricas de funciones. +* Callbacks. +* Encapsulación de estado. +* Configuración de comportamiento. +* Diversas formas de programación funcional. + +--- + +## 6. Captura de variables + +La captura es una de las áreas donde más se diferencian los lenguajes. + +### C++ + +En C++, la lambda incluye explícitamente una cláusula de captura: + +```cpp +int incremento = 10; + +auto sumar = [incremento](int x) { + return x + incremento; +}; +``` + +La variable puede capturarse por copia: + +```cpp +[incremento] +``` + +o por referencia: + +```cpp +[&incremento] +``` + +También existen capturas por defecto: + +```cpp +[=] // captura por copia +[&] // captura por referencia +``` + +El estándar del lenguaje trata la lambda como una expresión que genera un tipo de cierre único y sin nombre; la cláusula de captura determina qué variables externas estarán disponibles dentro de su cuerpo [6]. + +### C# + +En C#, una lambda puede capturar variables del ámbito circundante. La documentación de Microsoft señala que una lambda que necesita variables externas forma un cierre. + +También existe la posibilidad de utilizar lambdas `static`, que impiden la captura accidental de variables externas [5]. + +### Java + +En Java, las lambdas pueden acceder a variables locales del contexto cuando estas son `final` o **efectivamente finales**. Esto evita que el comportamiento dependa de cambios arbitrarios en variables locales después de crear la lambda [4]. + +--- + +## 7. Ámbito y duración de las variables capturadas + +La captura de variables introduce preguntas importantes sobre alcance (*scope*) y vida útil (*lifetime*). + +Por ejemplo: + +```python +def crear_contador(): + contador = 0 + + def incrementar(): + nonlocal contador + contador += 1 + return contador + + return incrementar +``` + +El objeto retornado mantiene acceso al estado necesario para seguir funcionando. + +En lenguajes con gestión automática de memoria, como Java, C#, JavaScript, Kotlin y Python, la representación interna del cierre puede permitir que los objetos capturados permanezcan vivos mientras exista una referencia al cierre. + +En C++, en cambio, la elección entre captura por copia y referencia obliga al programador a considerar cuidadosamente la duración del objeto referenciado. + +Por esta razón, una lambda pequeña no siempre implica una operación trivial a nivel de memoria. + +--- + +## 8. Tipado de expresiones lambda + +El tratamiento de los tipos depende del lenguaje. + +### Java + +Java utiliza **interfaces funcionales**, es decir, interfaces con un único método abstracto. + +Por ejemplo: + +```java +interface Operacion { + int calcular(int a, int b); +} + +Operacion suma = (a, b) -> a + b; +``` + +El tipo de la lambda se obtiene mediante el contexto esperado. Oracle describe este mecanismo como *target typing*: el compilador determina el tipo compatible de la lambda a partir del contexto en el que aparece [4]. + +También pueden utilizarse interfaces estándar: + +```java +Function doble = x -> x * 2; + +Predicate par = x -> x % 2 == 0; +``` + +### C# + +C# permite asociar lambdas con tipos delegado: + +```csharp +Func doble = x => x * 2; +``` + +También puede convertir determinadas lambdas en **árboles de expresión**, lo que permite representar su estructura como datos en lugar de ejecutarla directamente. + +Esta característica es especialmente relevante para proveedores de consultas que traducen expresiones a otros lenguajes o formatos [5]. + +### C++ + +C++ utiliza un tipo de cierre generado por el compilador. La lambda puede almacenarse con `auto`: + +```cpp +auto doble = [](int x) { + return x * 2; +}; +``` + +Las lambdas sin captura también pueden convertirse a punteros a función compatibles en los casos permitidos por el lenguaje [6]. + +### Python + +Python es dinámico. Una lambda produce un objeto función: + +```python +doble = lambda x: x * 2 +``` + +No requiere declarar un tipo de función independiente. Su restricción sintáctica principal es que el cuerpo debe ser una única expresión [3]. + +--- + +## 9. Sintaxis y diferencias entre lenguajes + +| Lenguaje | Sintaxis representativa | Captura | Característica destacada | +| -------------- | ------------------------------ | ------------------------------------------------- | ------------------------------------------------------- | +| **Python** | `lambda x: x * 2` | Ámbito léxico | Una sola expresión | +| **Java** | `x -> x * 2` | Variables locales finales o efectivamente finales | Interfaces funcionales | +| **C#** | `x => x * 2` | Cierres | Delegados y árboles de expresión | +| **C++** | `[&](int x) { return x * 2; }` | Copia o referencia | Tipo de cierre y captura explícita | +| **JavaScript** | `x => x * 2` | Ámbito léxico | `this` distinto al de funciones tradicionales | +| **Kotlin** | `{ x -> x * 2 }` | Contexto léxico | Lambdas y funciones anónimas como literales funcionales | + +Las funciones flecha de JavaScript tienen una característica especialmente importante: no crean sus propias vinculaciones para `this`, `arguments` o `super`, por lo que no deben considerarse simplemente una abreviatura sintáctica perfecta de una función tradicional [7]. + +MDN también distingue las funciones anónimas tradicionales de las funciones flecha y documenta sus diferencias de comportamiento [8]. + +Kotlin, por su parte, distingue formalmente entre *lambda literals* y declaraciones de funciones anónimas. Ambas permiten definir una función en línea, pero presentan diferencias de sintaxis y semántica [9]. + +--- + +## 10. Lambdas de expresión y lambdas de instrucciones + +Algunos lenguajes permiten que el cuerpo sea una expresión simple o un bloque de instrucciones. + +En C#: + +```csharp +Func cuadrado = x => x * x; +``` + +es una **lambda de expresión**. + +Mientras que: + +```csharp +Action imprimir = nombre => +{ + string mensaje = "Hola " + nombre; + Console.WriteLine(mensaje); +}; +``` + +es una **lambda de instrucciones** [5]. + +Java también permite cuerpos expresados como una sola expresión o bloques con `return`, dependiendo del tipo de lambda [4]. + +Esta diferencia afecta la claridad del código. Una lambda corta suele mejorar la legibilidad; una lambda demasiado extensa puede convertirse en una función anónima difícil de mantener. + +--- + +## 11. Diferencia entre función anónima, lambda y closure + +Estos términos se relacionan, pero no son completamente sinónimos: + +| Concepto | Definición | +| -------------------- | ----------------------------------------------------------------------------------------------------- | +| **Función anónima** | Función que no tiene un nombre explícito en su definición. | +| **Expresión lambda** | Construcción sintáctica para expresar una función de forma compacta. | +| **Closure** | Función junto con el entorno léxico que conserva las variables externas necesarias para su ejecución. | + +Una representación conceptual sería: + +```text +Función anónima + | + +-- puede expresarse mediante una lambda + | + v + Expresión lambda + | + +-- si captura variables externas + v + Closure +``` + +No todas las lambdas necesitan capturar variables, por lo que una lambda puede existir sin ser un *closure* en el sentido práctico de conservar estado externo. + +--- + +## 12. Callbacks y programación orientada a eventos + +Las funciones anónimas son especialmente útiles como **callbacks**. + +JavaScript ofrece un ejemplo clásico: + +```javascript +button.addEventListener("click", () => { + console.log("Botón presionado"); +}); +``` + +La función no necesita un nombre porque solamente se utiliza como comportamiento asociado al evento. + +El mismo patrón aparece en: + +* Interfaces gráficas. +* Temporizadores. +* Operaciones asíncronas. +* Procesamiento de colecciones. +* Tareas concurrentes. +* Validaciones. +* Operaciones de ordenamiento. +* Consultas de datos. +* APIs que aceptan funciones de configuración o transformación. + +Este patrón permite colocar el comportamiento cerca del lugar donde se utiliza. + +--- + +## 13. Asincronía y lambdas + +Las lambdas también se combinan con operaciones asíncronas. + +Por ejemplo, C# permite lambdas asíncronas: + +```csharp +Func tarea = async () => +{ + await ProcesarAsync(); +}; +``` + +Esto es útil cuando una API acepta una función que debe ejecutar operaciones `await`. + +JavaScript utiliza funciones flecha con `async`: + +```javascript +const obtenerDatos = async () => { + const respuesta = await fetch("/api/datos"); + return respuesta.json(); +}; +``` + +En estos casos la función anónima no solo encapsula comportamiento, sino también una unidad de flujo asíncrono. + +--- + +## 14. Ventajas + +Las funciones anónimas y lambdas ofrecen varias ventajas: + +### Reducción de código + +Permiten representar operaciones pequeñas sin declarar funciones separadas. + +### Localidad del comportamiento + +El código puede colocarse junto al punto donde se utiliza. + +### Composición + +Facilitan construir operaciones de orden superior. + +### Reutilización de algoritmos + +Una misma función puede recibir diferentes estrategias de procesamiento. + +### Callbacks + +Son adecuadas para eventos, tareas y operaciones asincrónicas. + +### Programación funcional + +Favorecen el uso de `map`, `filter`, `reduce`, composición y transformaciones. + +### Expresividad + +En operaciones simples pueden hacer más evidente la intención del programa. + +Java, por ejemplo, documenta que las lambdas permiten tratar el comportamiento como un argumento, mientras C# las utiliza extensamente junto con delegados y LINQ [4], [5]. + +--- + +## 15. Desventajas y riesgos + +El uso excesivo también puede introducir problemas: + +* **Legibilidad:** una lambda demasiado larga puede ser más difícil de entender que una función con nombre. +* **Depuración:** algunas herramientas muestran nombres generados internamente, lo cual puede dificultar la lectura de una traza. +* **Capturas accidentales:** una lambda puede mantener vivos objetos que ya no eran necesarios. +* **Costos de memoria:** determinados cierres requieren objetos o estructuras auxiliares. +* **Complejidad de tipos:** en lenguajes fuertemente tipados, las lambdas pueden involucrar inferencia, conversiones y sobrecarga complejas. +* **Errores de ciclo de vida:** las capturas por referencia en C++ requieren especial cuidado. +* **Abstracción excesiva:** transformar todo algoritmo en una cadena de lambdas puede disminuir la mantenibilidad. + +Por estas razones, una lambda debe utilizarse cuando aporta claridad y no únicamente por ser una sintaxis moderna. + +--- + +## 16. Rendimiento e implementación + +No existe una regla universal que indique que una lambda es siempre más rápida o más lenta que una función tradicional. + +La implementación depende del: + +* Lenguaje. +* Compilador. +* Entorno de ejecución. +* Contexto. +* Optimizaciones disponibles. + +En lenguajes compilados, una lambda puede transformarse en: + +* Una función especializada. +* Un objeto de cierre. +* Una función estática. +* Un objeto temporal. +* Código potencialmente *inlineado*. + +C++ define explícitamente un tipo de cierre sin nombre para cada lambda [6]. En otros lenguajes administrados pueden existir representaciones internas diferentes. + +Por ello, comparar rendimiento únicamente a partir de la sintaxis *función nombrada frente a lambda* es incorrecto. El rendimiento real debe evaluarse mediante el modelo de ejecución específico y, cuando sea necesario, mediante mediciones. + +--- + +## 17. Aplicaciones prácticas + +Las funciones anónimas y expresiones lambda aparecen en numerosos escenarios: + +```text + FUNCIONES ANÓNIMAS Y LAMBDAS + | + +-----------------+-----------------+ + | | | + v v v + Colecciones Eventos Asincronía + | | | + map/filter callbacks async/await + | | | + +-----------------+-----------------+ + | + v + Funciones de orden + superior + | + v + Closures +``` + +Entre sus aplicaciones prácticas se encuentran: + +* Filtrar estudiantes por promedio. +* Ordenar productos por precio. +* Validar formularios. +* Procesar respuestas HTTP. +* Ejecutar callbacks de eventos. +* Definir estrategias de búsqueda. +* Crear funciones parametrizadas. +* Construir pipelines de transformación. +* Implementar algoritmos genéricos. +* Encapsular estado temporal. + +--- + +## 18. Comparación de estilos + +Una función con nombre puede ser preferible cuando la operación es reutilizada: + +```python +def es_par(numero): + return numero % 2 == 0 + + +pares = list(filter(es_par, numeros)) +``` + +Una lambda es apropiada cuando la operación es local y sencilla: + +```python +pares = list(filter(lambda numero: numero % 2 == 0, numeros)) +``` + +La diferencia más importante no es solamente la cantidad de caracteres. Se relaciona con la intención y el alcance de reutilización. + +Como regla práctica: + +```text +Operación pequeña + uso local + | + v + Lambda + + +Operación compleja + reutilización + | + v + Función con nombre +``` + +--- + +## 19. Errores frecuentes + +### Lambda demasiado grande + +Por ejemplo: + +```python +resultado = lambda x: ( + x * 2 + 10 if x > 5 + else x - 3 +) +``` + +Aunque es posible, una función con nombre puede ser más clara si la lógica continúa creciendo. + +### Captura de una variable equivocada + +Las capturas deben entenderse antes de utilizar una lambda dentro de tareas diferidas o callbacks. + +### Confundir lambda con closure + +No toda lambda captura variables externas. + +### Asumir que todas las lambdas se comportan igual + +La sintaxis puede ser parecida, pero `this` de JavaScript, las interfaces funcionales de Java, la captura de C++ y los árboles de expresión de C# muestran diferencias importantes [4]–[9]. + +--- + +## 20. Buenas prácticas + +Para aprovechar correctamente las expresiones lambda se recomienda: + +1. Mantenerlas pequeñas cuando su lógica sea local. +2. Elegir nombres claros para las variables de los parámetros. +3. Evitar anidar lambdas innecesariamente. +4. Considerar una función con nombre cuando la lógica sea compleja. +5. Revisar qué variables se están capturando. +6. En C++, elegir conscientemente captura por copia o referencia. +7. En C#, considerar lambdas `static` cuando no deba existir captura. +8. No asumir que una lambda implica automáticamente mejor rendimiento. +9. Utilizar las APIs funcionales del lenguaje cuando mejoren la claridad. +10. Probar y perfilar el código cuando existan requisitos de rendimiento. + +--- + +# Conclusiones + +Las funciones anónimas y las expresiones lambda constituyen una herramienta fundamental de los lenguajes modernos, ya que permiten representar comportamiento como un valor y facilitar el uso de funciones de orden superior. + +Su fundamento conceptual está relacionado con el cálculo lambda, que proporciona una base formal para la abstracción y aplicación de funciones. Los lenguajes actuales incorporan estas ideas dentro de sistemas mucho más amplios de tipos, objetos y administración de memoria [1], [2]. + +La principal ventaja práctica de las lambdas es la composición de comportamiento, especialmente en operaciones sobre colecciones, callbacks, eventos, procesamiento asíncrono y patrones funcionales. + +Los closures amplían el concepto al permitir conservar variables del contexto léxico, pero también introducen consideraciones relacionadas con alcance, duración de objetos y uso de memoria. + +La implementación varía considerablemente entre lenguajes. Java depende de interfaces funcionales y tipado contextual; C# utiliza delegados y árboles de expresión; C++ emplea tipos de cierre y captura explícita; Python limita el cuerpo lambda a una expresión; JavaScript distingue significativamente las funciones flecha de las funciones tradicionales; y Kotlin diferencia lambdas de funciones anónimas [3]–[9]. + +Una lambda no siempre es la mejor opción. Cuando la lógica es extensa, se reutiliza frecuentemente o necesita una explicación semántica propia, una función con nombre suele proporcionar mayor claridad y mantenibilidad. + +En consecuencia, las funciones anónimas y las expresiones lambda deben entenderse no solo como una abreviatura sintáctica, sino como parte de un modelo de programación que permite tratar el comportamiento como dato, fomentar la abstracción y construir software más composicional. + +--- + +# Bibliografía + +[1] A. Church, "A set of postulates for the foundation of logic," *Annals of Mathematics*, 2nd ser., vol. 33, no. 2, pp. 346–366, 1932. + +[2] H. Abelson, G. J. Sussman, and J. Sussman, *Structure and Interpretation of Computer Programs*, 2nd ed. Cambridge, MA, USA: MIT Press, 1996. + +[3] Python Software Foundation, "6.14. Lambdas," *Python 3.14 Documentation*. [En línea]. Disponible en: https://docs.python.org/3/reference/expressions.html#lambda. [Accedido: 5-sep-2026]. + +[4] Oracle, "Lambda Expressions," *The Java Tutorials*. [En línea]. Disponible en: https://docs.oracle.com/javase/tutorial/java/javaOO/lambdaexpressions.html. [Accedido: 5-sep-2026]. + +[5] Microsoft, "Expresiones lambda: expresiones lambda y funciones anónimas," *Microsoft Learn, C# reference*. [En línea]. Disponible en: https://learn.microsoft.com/es-es/dotnet/csharp/language-reference/operators/lambda-expressions. [Accedido: 5-sep-2026]. + +[6] cppreference.com, "Lambda expressions (since C++11)," *C++ language reference*. [En línea]. Disponible en: https://en.cppreference.com/w/cpp/language/lambda. [Accedido: 5-sep-2026]. + +[7] Mozilla Developer Network, "Arrow function expressions," *MDN Web Docs*. [En línea]. Disponible en: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Arrow_functions. [Accedido: 5-sep-2026]. + +[8] Mozilla Developer Network, "Functions," *MDN Web Docs*. [En línea]. Disponible en: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions. [Accedido: 5-sep-2026]. + +[9] Kotlin Foundation, "Higher-order functions and lambdas," *Kotlin Documentation*. [En línea]. Disponible en: https://kotlinlang.org/docs/lambdas.html. [Accedido: 5-sep-2026]. + +[10] J. R. Hindley and J. P. Seldin, *Lambda-Calculus and Combinators: An Introduction*, 2nd ed. Cambridge, U.K.: Cambridge University Press, 2008. From 8a0aefe3c58bceec4f40de0bb23bb79eb1bf0fa9 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:56:17 -0700 Subject: [PATCH 5/9] Create anexo.md --- .../Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" | 1 + 1 file changed, 1 insertion(+) create mode 100644 "research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" new file mode 100644 index 0000000..8b13789 --- /dev/null +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" @@ -0,0 +1 @@ + From e4f938c3570b0ab170940e0426460b67311e2cc4 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:57:47 -0700 Subject: [PATCH 6/9] Update anexo.md --- .../anexo.md" | 103 ++++++++++++++++++ 1 file changed, 103 insertions(+) diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" index 8b13789..7c24f78 100644 --- "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/anexo.md" @@ -1 +1,104 @@ +# Bitácora de Uso de Modelo de Lenguaje (LLM) + +El presente anexo documenta el uso del **Modelo de Lenguaje de Gran Escala (LLM)** como herramienta de apoyo durante la elaboración de la investigación sobre **Funciones anónimas y expresiones lambda**. + +El LLM se empleó como **herramienta complementaria** para tareas de organización, síntesis, revisión de redacción y adaptación del material al formato Markdown. Las referencias técnicas se consideraron y verificaron a partir de documentación y fuentes especializadas, evitando tratar al LLM como una fuente bibliográfica primaria. + +--- + +## 1. Prompts Utilizados + +### Prompt 1: Definición del objetivo y alcance de la investigación + +> **Usuario:** +> +> "Estoy elaborando una investigación académica sobre las funciones anónimas y las expresiones lambda. La información debe sustentarse en bibliografía y documentación técnica especializada. Utiliza el LLM únicamente como herramienta de apoyo para organizar, sintetizar y redactar el material que te proporcione. No consideres al modelo como fuente bibliográfica primaria." + +### Prompt 2: Organización del material recopilado + +> **Usuario:** +> +> "A partir de la información técnica que te proporcionaré de diferentes fuentes, organiza el contenido de forma lógica y coherente. Conserva la terminología propia de los lenguajes de programación y diferencia claramente los conceptos de función anónima, expresión lambda, función de orden superior y closure. Utiliza el contenido proporcionado como base y evita presentar opiniones del modelo como hechos documentales." + +### Prompt 3: Ampliación y comparación de conceptos + +> **Usuario:** +> +> "Ayúdame a estructurar una comparación técnica de las funciones anónimas y expresiones lambda en diferentes lenguajes, especialmente Python, Java, C++, C#, JavaScript y Kotlin. El objetivo es complementar la información previamente recopilada y presentar las diferencias de sintaxis, tipado, captura de variables y usos. La información debe relacionarse con documentación técnica verificable." + +### Prompt 4: Conversión a Markdown + +> **Usuario:** +> +> "Convierte el contenido de la investigación que te proporcionaré a un documento Markdown completo y compatible con GitHub. Utiliza encabezados, tablas, listas, bloques de código y diagramas ASCII cuando sean útiles. Mantén el contenido técnico y no inventes referencias bibliográficas." + +### Prompt 5: Revisión académica del documento + +> **Usuario:** +> +> "Revisa la estructura del documento para mejorar su presentación académica. Verifica la consistencia de los encabezados, tablas, listas, bloques de código, ejemplos y conclusiones. Realiza principalmente correcciones de estructura, claridad y formato, manteniendo el contenido técnico basado en las fuentes consultadas." + +### Prompt 6: Revisión de conclusiones y bibliografía + +> **Usuario:** +> +> "Ayúdame a mejorar la redacción de las conclusiones y a presentar la bibliografía de manera uniforme en formato IEEE. La selección y verificación de las fuentes pertenece al proceso de investigación; utiliza el LLM únicamente como apoyo para organizar y presentar correctamente esta información." + +--- + +## 2. Resultados Obtenidos + +El uso del LLM permitió complementar el trabajo académico principalmente en las siguientes actividades: + +* **Organización temática:** Se estructuraron los contenidos en fundamentos, sintaxis, closures, funciones de orden superior, tipado, diferencias entre lenguajes, ventajas, limitaciones y buenas prácticas. + +* **Síntesis y redacción:** Se mejoró la claridad de explicaciones técnicas relacionadas con funciones anónimas, expresiones lambda y captura de variables. + +* **Comparación entre lenguajes:** Se apoyó la presentación de diferencias entre Python, Java, C++, C#, JavaScript y Kotlin. + +* **Generación de ejemplos:** Se prepararon ejemplos breves para ilustrar la sintaxis y los principales casos de uso. + +* **Conversión a Markdown:** El material se organizó mediante encabezados, tablas, listas, bloques de código y diagramas en texto para facilitar su publicación en GitHub. + +* **Revisión de formato:** Se corrigieron elementos de estructura, numeración, tablas y bloques de código para mantener una presentación uniforme. + +--- + +## 3. Reflexión Crítica + +### ¿Ayudó el uso del LLM? + +**Sí, como herramienta complementaria.** + +El LLM resultó útil principalmente para acelerar tareas de organización, síntesis, comparación, redacción y formato. También permitió detectar problemas de estructura y convertir el material a una presentación Markdown más consistente. + +Su utilidad fue mayor en la **transformación y organización del contenido** que en la sustitución del proceso de investigación. La documentación técnica y las referencias bibliográficas constituyeron la base para contrastar los conceptos presentados. + +### ¿Hubo sesgos, alucinaciones o errores? + +Como cualquier modelo de lenguaje, el LLM puede producir afirmaciones incompletas, simplificaciones o errores técnicos. Por ello, sus respuestas no se consideraron automáticamente como correctas ni como referencias bibliográficas. + +Se prestó especial atención a los siguientes puntos: + +1. **Diferencias entre lenguajes:** Se verificó que conceptos similares no fueran tratados como idénticos. Por ejemplo, la captura de variables en C++ posee reglas diferentes de las utilizadas por Java, C# o Python. + +2. **Funciones flecha en JavaScript:** Se consideró que una función flecha no es simplemente una abreviatura de una función tradicional, debido a diferencias semánticas relacionadas con `this`, `arguments`, `super` y la construcción con `new`. + +3. **Closures:** Se evitó asumir que toda lambda es automáticamente un closure. La captura de variables externas depende del contexto y de las reglas del lenguaje. + +4. **Tipado:** Se revisaron las diferencias entre interfaces funcionales en Java, delegados y árboles de expresión en C#, tipos de cierre en C++ y funciones objeto en Python. + +5. **Bibliografía:** Las referencias se organizaron a partir de documentación técnica, libros y recursos especializados, procurando evitar referencias inexistentes o atribuciones no verificadas. + +6. **Formato Markdown:** El LLM fue especialmente útil para detectar errores de sintaxis, numeración y presentación que podían afectar la visualización del proyecto en GitHub. + +--- + +## 4. Consideración Final sobre el Uso de IA + +El LLM se utilizó como una herramienta de **asistencia académica para organizar, sintetizar, comparar, revisar y formatear información**, no como sustituto del proceso de investigación ni como fuente bibliográfica primaria. + +La responsabilidad de revisar la exactitud de los conceptos, comprobar las referencias y decidir qué contenido incorporar al trabajo corresponde al autor de la investigación. + +El uso del modelo se limitó a facilitar el proceso de elaboración y presentación del material. From 99317cf6816b8de6a7fc59ad9f5cafd26fe91c04 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:58:19 -0700 Subject: [PATCH 7/9] Create ejemplos-lambda.md --- .../ejemplos-lambda.md" | 1 + 1 file changed, 1 insertion(+) create mode 100644 "research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" new file mode 100644 index 0000000..8b13789 --- /dev/null +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" @@ -0,0 +1 @@ + From 9555067144fa381facad1b01900c63abc4df5b4a Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Sat, 5 Sep 2026 14:59:17 -0700 Subject: [PATCH 8/9] Update ejemplos-lambda.md --- .../ejemplos-lambda.md" | 361 ++++++++++++++++++ 1 file changed, 361 insertions(+) diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" index 8b13789..73389aa 100644 --- "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/ejemplos-lambda.md" @@ -1 +1,362 @@ +# Ejemplos ejecutables de funciones anónimas y expresiones lambda + +Este documento contiene ejemplos ejecutables de **funciones anónimas y expresiones lambda** en Python, Java, C++, C#, JavaScript y Kotlin. + +Los ejemplos muestran operaciones comunes como filtrado, transformación de datos, funciones de orden superior y captura de variables. + +--- + +## Python + +### Código + +```python +numeros = [1, 2, 3, 4, 5, 6] + +pares = list(filter(lambda x: x % 2 == 0, numeros)) +cuadrados = list(map(lambda x: x * x, numeros)) + +print("Pares:", pares) +print("Cuadrados:", cuadrados) + + +def crear_incrementador(n): + return lambda x: x + n + + +sumar_10 = crear_incrementador(10) + +print("5 + 10 =", sumar_10(5)) +``` + +### Ejecución esperada + +```text +Pares: [2, 4, 6] +Cuadrados: [1, 4, 9, 16, 25, 36] +5 + 10 = 15 +``` + +### Conceptos demostrados + +* Funciones lambda. +* `filter()`. +* `map()`. +* Funciones de orden superior. +* Captura de variables. +* Closures. + +--- + +## Java + +### Código + +```java +import java.util.function.Function; +import java.util.function.Predicate; + +public class LambdaDemo { + public static void main(String[] args) { + Function doble = x -> x * 2; + Predicate par = x -> x % 2 == 0; + + System.out.println(doble.apply(10)); + System.out.println(par.test(10)); + } +} +``` + +### Compilación y ejecución + +Guardar el archivo como: + +```text +LambdaDemo.java +``` + +Compilar: + +```bash +javac LambdaDemo.java +``` + +Ejecutar: + +```bash +java LambdaDemo +``` + +### Salida esperada + +```text +20 +true +``` + +### Conceptos demostrados + +* Expresiones lambda. +* Interfaces funcionales. +* `Function`. +* `Predicate`. +* Inferencia de tipos mediante el contexto. + +--- + +## C++ + +### Código + +```cpp +#include +#include +#include + +int main() { + std::vector numeros = {1, 2, 3, 4, 5, 6}; + + std::for_each(numeros.begin(), numeros.end(), [](int x) { + if (x % 2 == 0) { + std::cout << x << " "; + } + }); + + std::cout << '\n'; + + return 0; +} +``` + +### Compilación y ejecución + +Guardar el archivo como: + +```text +lambda.cpp +``` + +Compilar: + +```bash +g++ -std=c++17 lambda.cpp -o lambda +``` + +Ejecutar: + +```bash +./lambda +``` + +### Salida esperada + +```text +2 4 6 +``` + +### Conceptos demostrados + +* Lambda sin captura. +* Función de orden superior. +* `std::for_each`. +* Tipo de cierre generado por el compilador. + +--- + +## C# + +### Código + +```csharp +using System; + +class LambdaDemo +{ + static void Main() + { + Func doble = x => x * 2; + Func esPar = x => x % 2 == 0; + + Console.WriteLine(doble(10)); + Console.WriteLine(esPar(10)); + } +} +``` + +### Ejecución + +En un proyecto .NET, ejecutar: + +```bash +dotnet run +``` + +### Salida esperada + +```text +20 +True +``` + +### Conceptos demostrados + +* Expresiones lambda. +* Delegados genéricos. +* `Func`. +* Inferencia de tipos. +* Funciones que devuelven valores. + +--- + +## JavaScript + +### Código + +```javascript +const numeros = [1, 2, 3, 4, 5, 6]; + +const pares = numeros.filter(x => x % 2 === 0); +const cuadrados = numeros.map(x => x * x); + +console.log("Pares:", pares); +console.log("Cuadrados:", cuadrados); +``` + +### Ejecución + +Guardar el código como: + +```text +lambda.js +``` + +Ejecutar con Node.js: + +```bash +node lambda.js +``` + +### Salida esperada + +```text +Pares: [ 2, 4, 6 ] +Cuadrados: [ 1, 4, 9, 16, 25, 36 ] +``` + +### Conceptos demostrados + +* Funciones flecha. +* `filter()`. +* `map()`. +* Funciones de orden superior. +* Funciones anónimas. + +--- + +## Kotlin + +### Código + +```kotlin +fun main() { + val numeros = listOf(1, 2, 3, 4, 5, 6) + + val pares = numeros.filter { it % 2 == 0 } + val cuadrados = numeros.map { it * it } + + println("Pares: $pares") + println("Cuadrados: $cuadrados") +} +``` + +### Salida esperada + +```text +Pares: [2, 4, 6] +Cuadrados: [1, 4, 9, 16, 25, 36] +``` + +### Conceptos demostrados + +* Lambdas. +* `filter()`. +* `map()`. +* Parámetro implícito `it`. +* Funciones de orden superior. + +--- + +# Comparación de los ejemplos + +| Lenguaje | Construcción utilizada | Funciones de orden superior | Captura / Closure | +| -------------- | ---------------------- | --------------------------- | ----------------- | +| **Python** | `lambda x: ...` | `map()`, `filter()` | Sí | +| **Java** | `x -> ...` | Interfaces funcionales | Sí | +| **C++** | `[](int x) { ... }` | `std::for_each` | Sí | +| **C#** | `x => ...` | Delegados | Sí | +| **JavaScript** | `x => ...` | `map()`, `filter()` | Sí | +| **Kotlin** | `{ it -> ... }` | `map()`, `filter()` | Sí | + +Aunque todos los ejemplos implementan conceptos similares, cada lenguaje utiliza un modelo particular para representar las funciones y administrar su captura de variables. + +--- + +# Diagrama conceptual + +```text + FUNCIÓN ANÓNIMA / LAMBDA + | + +--------------+--------------+ + | | + v v + Función de primera Puede capturar + clase variables + | | + v v + Se pasa como argumento CLOSURE + | + v + Función de orden superior + | + +-----+-----+ + | | | + v v v + map filter reduce +``` + +--- + +# Resumen de los conceptos demostrados + +Los ejemplos anteriores permiten observar cómo las funciones anónimas y las expresiones lambda se utilizan en diferentes paradigmas y lenguajes de programación. + +### Funciones de primera clase + +Las funciones pueden ser almacenadas, utilizadas como argumentos o devueltas por otras funciones. + +### Funciones de orden superior + +Funciones como `map()`, `filter()` y `for_each` reciben comportamiento como argumento para realizar operaciones genéricas. + +### Closures + +Una función puede conservar acceso a variables pertenecientes al contexto donde fue creada. + +### Sintaxis compacta + +Las lambdas permiten expresar operaciones pequeñas sin necesidad de declarar funciones con nombre independientes. + +### Diferencias entre lenguajes + +La idea general es similar, pero la sintaxis, el sistema de tipos, las reglas de captura y la representación interna dependen del lenguaje utilizado. + +--- + +# Conclusión + +Los ejemplos muestran que las funciones anónimas y las expresiones lambda constituyen una herramienta ampliamente utilizada en los lenguajes de programación modernos. + +Python, Java, C++, C#, JavaScript y Kotlin proporcionan mecanismos para representar comportamiento de manera compacta y utilizarlo como dato. Esto facilita especialmente el procesamiento de colecciones, los callbacks y las funciones de orden superior. + +Sin embargo, las diferencias entre lenguajes son importantes. Por ello, aprender únicamente la sintaxis de una lambda no es suficiente; también es necesario comprender su sistema de tipos, las reglas de captura y el modelo de ejecución correspondiente. From b9b72cade531e3d6f0f36bf1858ec6eb18b5a380 Mon Sep 17 00:00:00 2001 From: l23211974-maker Date: Thu, 10 Sep 2026 23:31:32 -0700 Subject: [PATCH 9/9] Update README.md --- .../Funciones-an\303\263nimas-y-expresiones-lambda/README.md" | 1 + 1 file changed, 1 insertion(+) diff --git "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" index cee5cef..7dc9909 100644 --- "a/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" +++ "b/research/Funciones-an\303\263nimas-y-expresiones-lambda/README.md" @@ -1,3 +1,4 @@ +#Grande Ortega Maximiliano Alberto No.23211974 # Funciones Anónimas y Expresiones Lambda ## Introducción