Pipeline funcional limpio sin sobrecarga de mónadas: el toolkit fp-pack para JavaScript y TypeScriptArtículo · digest del 17 de noviembre
Esquema isométrico en corte con un conducto modular de pasos funcionales pipe sin dependencias externas.
Artículo3 secciones≈ 8 min

Pipeline funcional limpio sin sobrecarga de mónadas: el toolkit fp-pack para JavaScript y TypeScript

Desde el backend de una tienda online llega un array crudo de pedidos. Hay que filtrar las compras completadas, agruparlas por cliente, calcular los ingresos de cada uno y devolver un error claro si la lista viene vacía. En TypeScript convencional, una tarea así se llena enseguida de variables intermedias, llamadas anidadas y comprobaciones que acaban ocultando la lógica principal.

Para conseguir cadenas lineales se suelen instalar herramientas pesadas como Ramda o fp-ts, pagando el peaje del tamaño del bundle o de tener que envolver cada valor en mónadas. En la selección de Best of JS di con fp-pack, del desarrollador superlucky84 (rama actual 0.16.0). Me llamó la atención su apuesta pragmática: cero dependencias, sin envoltorios monádicos, inferencia estricta de tipos y salida anticipada limpia cuando algo falla.

De los paréntesis anidados a un flujo lineal de datos

Los primeros pasos para transformar el array de pedidos con los métodos nativos de JavaScript se ven ordenados, pero en cuanto toca agrupar por cliente la cadena se rompe:

interface Order {
  id: string;
  customerId: string;
  amount: number;
  status: 'pending' | 'completed' | 'cancelled';
}

const orders: Order[] = [
  { id: 'ord-1', customerId: 'cust-a', amount: 1500, status: 'completed' },
  { id: 'ord-2', customerId: 'cust-b', amount: 400, status: 'pending' },
  { id: 'ord-3', customerId: 'cust-a', amount: 2200, status: 'completed' },
  { id: 'ord-4', customerId: 'cust-c', amount: 900, status: 'cancelled' },
];

const completed = orders.filter((order) => order.status === 'completed');

const revenueByCustomer = completed.reduce<Record<string, number>>((acc, order) => {
  acc[order.customerId] = (acc[order.customerId] ?? 0) + order.amount;
  return acc;
}, {});

Aquí hay dos problemas. En cada llamada a .filter() o .map() se reserva en memoria un nuevo array intermedio, y cualquier paso no estándar como agrupar te obliga a cortar la cadena y pasar a un reduce manual.

Si sustituyes los métodos de array por funciones normales, acabas leyendo las llamadas anidadas de dentro hacia fuera. Para convertir el procesamiento en un flujo directo de arriba abajo hace falta una forma uniforme de componer sin capas extra.

Pipe-first, currificación automática e inferencia de tipos hasta 32 pasos

La lógica de fp-pack parte de una regla sencilla: si todas las utilidades con varios argumentos reciben los datos al final y vienen currificadas por defecto, encajan en un pipeline de izquierda a derecha. El paquete se instala sin dependencias transitivas:

npm install fp-pack
# o bien
pnpm add fp-pack

La librería reúne más de 96 funciones en 10 categorías: arrays, objetos, cadenas, matemáticas, asincronía, streams y control de flujo. Sus compilaciones para ESM, CommonJS y UMD soportan tree-shaking, de modo que en tu bundle solo entra el código que importas de verdad.

Reescribamos el cálculo de ingresos por cliente usando pipe:

import { pipe, filter, groupBy, mapValues, map, prop, sum } from 'fp-pack';

const revenueByCustomer = pipe(
  orders,
  filter((order) => order.status === 'completed'),
  groupBy((order) => order.customerId),
  mapValues((customerOrders) =>
    pipe(customerOrders, map(prop('amount')), sum)
  )
);
// { 'cust-a': 3700 }

Los datos orders van como primer argumento: es el modo value-first. Arranca el pipeline de inmediato y «ancla» los genéricos de TypeScript en Order[], así que el compilador infiere los tipos de todos los callbacks hasta 32 pasos por delante y, si algún encaje falla, muestra el diagnóstico PipeError.

Aquí no hace falta escribir adaptadores con funciones flecha: filter y groupBy ya están currificadas y devuelven funciones unarias listas para pipe. Si necesitas un transformador reutilizable sin ejecución inmediata, pipe también funciona en modo functions-first —solo funciones como entrada—, aunque si el primer paso es polimórfico conviene indicar explícitamente el tipo de entrada. Para tus propios helpers con parámetros por defecto o argumentos rest existe el envoltorio curryN.

Manejo de fallos sin mónadas, streams perezosos y el precio de la elección

En fp-ts, los errores se envuelven en contenedores Either o Maybe: es como transportar cada pieza por la cinta dentro de una cápsula sellada que hay que abrir y volver a cerrar en cada tramo con map o flatMap. En fp-pack eligieron otra metáfora: una válvula de alivio en la tubería. Mientras los pedidos son válidos, por el pipeline circulan valores normales; si un paso falla, devuelve el marcador SideEffect.of con una función diferida, y pipeSideEffect desvía el flujo saltándose las etapas restantes:

import {
  pipeSideEffect, pipe, SideEffect, isSideEffect, runPipeResult,
  filter, groupBy, mapValues, map, prop, sum,
} from 'fp-pack';

const calculateRevenue = pipeSideEffect(
  (input: Order[]) =>
    input.length > 0 ? input : SideEffect.of(() => ({ code: 'EMPTY_ORDERS' as const })),
  filter((order) => order.amount > 0 && order.status === 'completed'),
  (completed) =>
    completed.length > 0
      ? completed
      : SideEffect.of(() => ({ code: 'NO_VALID_COMPLETED' as const })),
  groupBy((order) => order.customerId),
  mapValues((customerOrders) => pipe(customerOrders, map(prop('amount')), sum))
);

const rawResult = calculateRevenue(orders);

const summary = isSideEffect(rawResult)
  ? { ok: false as const, error: runPipeResult(rawResult) }
  : { ok: true as const, revenueByCustomer: rawResult };

Aquí manda la regla de «contagio»: si al menos un paso devuelve SideEffect, la cadena exterior debe ir con pipeSideEffect (o pipeAsyncSideEffect en código asíncrono), mientras que dentro de mapValues, donde no hay efectos, sigue bastando un pipe puro.

Por fuera, el predicado isSideEffect estrecha los tipos: runPipeResult extrae la unión exacta de errores EMPTY_ORDERS o NO_VALID_COMPLETED, y en el caso válido queda el diccionario de ingresos. Eso sí, no amplíes manualmente el resultado a SideEffect<any>, porque el parámetro por defecto de runPipeResult degradaría la inferencia a any.

Cuando trabajas con cientos de miles de registros y no compensa crear arrays intermedios, tienes el módulo perezoso fp-pack/stream:

import { pipe } from 'fp-pack';
import { filter, map, take, toArray } from 'fp-pack/stream';

const firstFiveLargeOrders = pipe(
  filter((order: Order) => order.status === 'completed' && order.amount >= 1000),
  map((order) => ({ id: order.id, amount: order.amount })),
  take(5),
  toArray
);

const topOrders = firstFiveLargeOrders(orders);

Los operadores filter y map de stream trabajan sobre iteradores y detienen el recorrido en cuanto take(5) reúne cinco pedidos válidos, mientras toArray materializa únicamente esos cinco.

Frente a lodash/fp y Ramda, diseñados pensando en JavaScript dinámico, fp-pack gana por su autocompletado predecible en TypeScript; frente a fp-ts, cede en rigor académico pero vence con claridad en curva de entrada. Dentro del propio paquete npm vienen incluso skills y un complemento para agentes de programación, para que los asistentes de IA generen directamente cadenas con pipe y SideEffect.

Ten presentes dos límites: la rama 0.16.0 aún está antes de la 1.0, así que el autor va afinando tipos y retirando alias antiguos, y el playground interactivo en GitHub Pages nació con interfaz en coreano aunque la documentación está en inglés. Si te interesa el tipado estricto sin peso extra en runtime, echa un vistazo a nuestro análisis de gdp-ts con demostraciones formales en tipos y a la nota sobre reducción del tamaño de bundles en JavaScript.

No hace falta reescribir todo el proyecto a funciones puras en una tarde ni estudiar teoría de categorías. Coge una sola cadena enrevesada de transformación de arrays o respuestas de API, pásala a un pipe lineal y recurre a pipeSideEffect o fp-pack/stream únicamente donde necesites de verdad una salida temprana o evaluación perezosa.

Quiero un análisis detalladoLos votos ayudan a elegir qué analizar a fondo. Este material tiene 0 votos.
Fuentes · 2