TypeScript: Programación Funcional

La programación funcional es un paradigma que se centra en el uso de funciones puras y evita cambios de estado y datos mutables. En el contexto de TypeScript, este enfoque puede mejorar la claridad y mantenibilidad del código. A continuación, se presentan los conceptos clave de la programación funcional aplicada en TypeScript.

Funciones puras

Las funciones puras son aquellas que, para un mismo conjunto de entradas, siempre devuelven el mismo resultado y no tienen efectos secundarios. En TypeScript, podemos definir funciones puras de la siguiente manera:

function suma(a: number, b: number): number {
    return a + b;
}

Esta función suma es pura porque no modifica ninguna variable externa ni tiene efectos secundarios.

Inmutabilidad

La inmutabilidad es un principio fundamental en la programación funcional. Consiste en no modificar los datos una vez creados. En TypeScript, podemos usar const para asegurar que las variables no cambien:

const numeros: number[] = [1, 2, 3, 4, 5];
const nuevosNumeros = numeros.map(n => n * 2);

Aquí, numeros permanece inmutable, y nuevosNumeros es una nueva lista con los valores transformados.

Funciones de orden superior

Las funciones de orden superior son funciones que toman otras funciones como argumentos o devuelven funciones como resultado. En TypeScript, esto se puede lograr fácilmente:

function aplicarOperacion(arr: number[], operacion: (n: number) => number): number[] {
    return arr.map(operacion);
}

const doblar = (n: number) => n * 2;
const resultado = aplicarOperacion([1, 2, 3], doblar);

En este ejemplo, aplicarOperacion toma un array y una función, aplicando esta última a cada elemento del array.

Composición de funciones

La composición de funciones es el proceso de combinar dos o más funciones para producir una nueva función. En TypeScript, podemos componer funciones utilizando una biblioteca como lodash o implementándola manualmente:

const composicion = <T>(...funcs: ((arg: T) => T)[]) => (valorInicial: T): T =>
    funcs.reduce((valor, func) => func(valor), valorInicial);

const incrementar = (n: number) => n + 1;
const doblar = (n: number) => n * 2;

const incrementarYDoblar = composicion(incrementar, doblar);

const resultado = incrementarYDoblar(5); // 12

La función composicion toma una lista de funciones y las aplica secuencialmente.

Currificación

La currificación es el proceso de transformar una función que toma múltiples argumentos en una serie de funciones que toman un solo argumento. En TypeScript, esto puede implementarse así:

function suma(a: number): (b: number) => number {
    return function(b: number): number {
        return a + b;
    };
}

const sumaCinco = suma(5);
const resultado = sumaCinco(3); // 8

La función suma devuelve una nueva función que toma el segundo argumento y devuelve el resultado de sumar ambos.

Recursión

La recursión es una técnica donde una función se llama a sí misma para resolver un problema. En TypeScript, podemos usar recursión para problemas como el cálculo de factoriales:

function factorial(n: number): number {
    if (n <= 1) {
        return 1;
    }
    return n * factorial(n - 1);
}

const resultado = factorial(5); // 120

Este ejemplo muestra cómo calcular el factorial de un número utilizando recursión.