Programación funcional en TypeScript: de la A a la Z

Programación funcional en TypeScript: de la A a la Z

La programación funcional (PF) es un paradigma que considera los cálculos como la evaluación de funciones matemáticas y evita el cambio de estado y los datos mutables. TypeScript, al ser una extensión fuertemente tipada de JavaScript, proporciona una excelente base para aplicar los principios de la PF, permitiendo escribir código más predecible, comprobable y fiable. En este artículo, analizaremos los conceptos clave de la PF en TypeScript, comenzando por los fundamentos y llegando hasta las técnicas avanzadas.

Principios fundamentales de la programación funcional

Antes de profundizar en el código, es importante comprender los principios fundamentales sobre los que se basa la PF.

Funciones puras (Pure Functions)

Una función pura es una función que:

• Siempre devuelve el mismo resultado para los mismos argumentos (determinismo).
• No tiene efectos secundarios (no modifica variables externas, no imprime datos en la consola, no envía solicitudes).

Ejemplo de función pura:

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

// Siempre predecibleconsole.log(add(2, 3)); // 5console.log(add(2, 3)); // 5

Ejemplo de función impura:

let counter = 0;function increment(): number {  return ++counter; // Efecto secundario: modificación de una variable externa}

Inmutabilidad (Immutability)

Los datos no deben modificarse después de su creación. En lugar de modificar un objeto existente, creamos una nueva copia del mismo con los cambios necesarios.

interface User {  name: string;  age: number;}

const user: User = { name: "Alice", age: 30 };

// Malo (mutación)user.age = 31;

// Bueno (inmutabilidad)const updatedUser: User = { ...user, age: 31 };

console.log(user); // { name: "Alice", age: 30 } - el original no cambióconsole.log(updatedUser); // { name: "Alice", age: 31 }

Composición y currying en TypeScript

La composición de funciones es el proceso de combinar varias funciones simples para crear una más compleja. El currying es la transformación de una función con varios argumentos en una secuencia de funciones, cada una de las cuales toma un solo argumento.

Composición (Function Composition)

Implementación tipada de la composición en TypeScript:

function compose<A, B, C>(f: (x: B) => C, g: (x: A) => B): (x: A) => C {  return (x: A) => f(g(x));}

const toUpperCase = (str: string): string => str.toUpperCase();const exclaim = (str: string): string => `${str}!`;

const shout = compose(exclaim, toUpperCase);console.log(shout("hello world")); // "HELLO WORLD!"

Currying

Ejemplo de una función currificada:

function multiply(a: number): (b: number) => number {  return (b: number) => a * b;}

const double = multiply(2);const triple = multiply(3);

console.log(double(5)); // 10console.log(triple(5)); // 15

El currying hace que las funciones sean más flexibles y convenientes para la composición.

Trabajo con mónadas: Option y Result

Las mónadas son un patrón potente para trabajar con efectos secundarios y el manejo de errores sin violar la pureza de las funciones. En TypeScript se utilizan a menudo las mónadas Option (o Maybe) y Result (o Either).

Mónada Option (Maybe)

Permite trabajar de forma segura con valores que pueden ser null o undefined.

type Option<T> = T | null;

function safeDivide(a: number, b: number): Option<number> {  return b === 0 ? null : a / b;}

function getValue(value: Option<number>): string {  if (value === null) {    return "Error: división por cero";  }  return `Resultado: ${value}`;}

console.log(getValue(safeDivide(10, 2)