Programación Funcional en TypeScript

La programación funcional representa un paradigma de desarrollo que trata la computación como la evaluación de funciones matemáticas, evitando el cambio de estado y los datos mutables. En TypeScript, este enfoque cobra especial relevancia gracias a su sistema de tipos estático, que permite crear código funcional más seguro y expresivo.

Fundamentos del paradigma funcional

El paradigma funcional se basa en principios matemáticos donde las funciones puras constituyen la unidad básica de construcción. Una función pura siempre produce el mismo resultado para los mismos argumentos de entrada y no genera efectos secundarios observables.

// Función pura
const sumar = (a: number, b: number): number => a + b;

// Función impura (modifica estado externo)
let contador = 0;
const incrementar = (): number => ++contador;

La inmutabilidad es otro pilar fundamental. En lugar de modificar datos existentes, se crean nuevas estructuras con los cambios necesarios. TypeScript facilita este enfoque mediante el uso de tipos readonly y técnicas de clonado.

interface Usuario {
  readonly id: number;
  readonly nombre: string;
  readonly email: string;
}

const actualizarEmail = (usuario: Usuario, nuevoEmail: string): Usuario => ({
  ...usuario,
  email: nuevoEmail
});

Funciones de orden superior

Las funciones de orden superior son aquellas que reciben otras funciones como parámetros o las devuelven como resultado. TypeScript proporciona un tipado robusto para estas construcciones, mejorando la seguridad y la documentación del código.

type Predicado<T> = (item: T) -> boolean;
type Transformador<T, U> = (item: T) -> U;

const filtrarYTransformar = <T, U>(
  items: T[],
  predicado: Predicado<T>,
  transformador: Transformador<T, U>
): U[] => items.filter(predicado).map(transformador);

Composición de funciones

La composición permite combinar funciones simples para crear operaciones más complejas. Este enfoque modular facilita la reutilización y el testing del código.

const compose = <A, B, C>(f: (b: B) => C, g: (a: A) => B) => 
  (a: A): C => f(g(a));

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

const duplicarEIncrementar = compose(incrementar, duplicar);
// duplicarEIncrementar(3) -> 7

Currying y aplicación parcial

El currying transforma una función que acepta múltiples argumentos en una secuencia de funciones que aceptan un solo argumento. La aplicación parcial permite fijar algunos argumentos de una función, creando nuevas funciones especializadas.

const multiplicar = (a: number) => (b: number): number => a * b;

const duplicar = multiplicar(2);
const triplicar = multiplicar(3);

// Aplicación parcial con bind
const saludar = (saludo: string, nombre: string): string => 
  `${saludo}, ${nombre}!`;

const saludarFormalmente = saludar.bind(null, "Buenos días");

Manejo de efectos secundarios

Aunque la programación funcional busca minimizar los efectos secundarios, en aplicaciones reales son inevitables. TypeScript ofrece herramientas para encapsular y controlar estos efectos de manera predecible.

type IO<T> = () => T;

const leerArchivo = (ruta: string): IO<string> => 
  () => require('fs').readFileSync(ruta, 'utf8');

const procesarArchivo = (ruta: string): IO<string[]> => 
  () => leerArchivo(ruta)().split('\n');

Tipos algebraicos y pattern matching

Los tipos union de TypeScript permiten modelar datos de forma similar a los tipos algebraicos de lenguajes funcionales puros. Combinados con técnicas de pattern matching, proporcionan una forma elegante de manejar diferentes casos.

type Resultado<T, E> = 
  | { tipo: 'exito'; valor: T }
  | { tipo: 'error'; error: E };

const manejarResultado = <T, E>(resultado: Resultado<T, E>): string => {
  switch (resultado.tipo) {
    case 'exito':
      return `Éxito: ${resultado.valor}`;
    case 'error':
      return `Error: ${resultado.error}`;
  }
};

La programación funcional en TypeScript ofrece un enfoque estructurado para crear aplicaciones más predecibles y mantenibles. El sistema de tipos estático actúa como una red de seguridad que detecta errores en tiempo de compilación, mientras que los principios funcionales promueven código más modular y testeable.