Чистый функциональный пайплайн без монадического перегруза: инструментарий fp-pack для JavaScript и TypeScriptСтатья · дайджест за 17 ноября
Изометрическая схема в разрезе с модульным конвейером функциональных шагов pipe без внешних зависимостей.
Статья3 раздела≈ 7 мин

Чистый функциональный пайплайн без монадического перегруза: инструментарий fp-pack для JavaScript и TypeScript

С бэкенда интернет-магазина приходит сырой массив заказов. Нужно отфильтровать завершённые покупки, сгруппировать их по клиентам, посчитать выручку на каждого и вернуть понятную ошибку, если список пуст. В обычном TypeScript такая задача быстро обрастает промежуточными переменными, вложенными вызовами и проверками, за которыми теряется сама логика.

Ради линейных цепочек обычно ставят тяжёлые комбайны вроде Ramda или fp-ts, расплачиваясь весом бандла или необходимостью заворачивать значения в монады. В подборке Best of JS мне попался проект fp-pack от разработчика superlucky84 (актуальная ветка 0.16.0). Меня зацепила ставка на прагматизм: ноль зависимостей, никаких монадических обёрток, строгий вывод типов и чистый ранний выход при сбоях.

От вложенных скобок к линейному потоку данных

Первые шаги трансформации массива заказов на встроенных методах JavaScript выглядят аккуратно, но как только доходит до группировки по клиенту, цепочка обрывается:

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;
}, {});

Здесь две проблемы. На каждом вызове .filter() или .map() в памяти выделяется новый промежуточный массив, а нестандартный шаг вроде группировки сразу заставляет рвать цепочку и переходить к ручному reduce.

Если же заменить методы массива обычными функциями, вложенные вызовы приходится читать изнутри наружу. Чтобы превратить обработку в прямой поток сверху вниз, нужен единый способ композиции без лишних обёрток.

Pipe-first, автокаррирование и вывод типов на 32 шага

Логика fp-pack строится на простом правиле: если все многоаргументные утилиты принимают данные последним параметром и каррируются по умолчанию, они стыкуются в конвейер слева направо. Пакет ставится без транзитивных зависимостей:

npm install fp-pack
# или
pnpm add fp-pack

В библиотеке более 96 функций в 10 категориях — для массивов, объектов, строк, математики, асинхронности, потоков и управления ветвлением. Сборки под ESM, CommonJS и UMD поддерживают tree-shaking, так что в твой бандл попадёт только реально импортированный код.

Перепишем расчёт выручки по клиентам через 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 }

Данные orders идут первым аргументом — это режим value-first. Он сразу запускает конвейер и «якорит» дженерики TypeScript на Order[], поэтому компилятор сам выводит типы всех коллбэков до 32 шагов вперёд и при ошибке стыковки выдаёт диагностику PipeError.

Писать лишние стрелочные переходники здесь не нужно: filter и groupBy уже каррированы и возвращают готовые унарные функции для pipe. Если нужен переиспользуемый трансформер без немедленного запуска, pipe работает и в режиме functions-first — только функции на входе, хотя для полиморфного первого шага лучше явно указать входной тип. Для собственных хелперов с параметрами по умолчанию или rest-аргументами предусмотрена обёртка curryN.

Обработка сбоев без монад, ленивые потоки и цена выбора

В fp-ts ошибки заворачивают в контейнеры Either или Maybe: это как везти каждую деталь по конвейеру в запечатанной капсуле, которую на каждом участке приходится вскрывать и закрывать заново через map или flatMap. В fp-pack выбрали другой образ — аварийный клапан на трубе. Пока заказы валидны, по конвейеру текут обычные значения, а при сбое шаг возвращает маркер SideEffect.of с отложенной функцией, и pipeSideEffect сбрасывает поток мимо оставшихся этапов:

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 };

Здесь важно правило «заразности»: если хотя бы один шаг возвращает SideEffect, внешнюю цепочку нужно вести через pipeSideEffect (или pipeAsyncSideEffect для асинхронного кода), а внутри mapValues без эффектов спокойно остаётся чистый pipe.

Снаружи предикат isSideEffect сужает типы: runPipeResult извлекает точное объединение ошибок EMPTY_ORDERS или NO_VALID_COMPLETED, либо остаётся словарь выручки. Главное — не расширять результат вручную до SideEffect<any>, иначе параметр по умолчанию у runPipeResult сбросит вывод в any.

Для сотен тысяч записей, где накладно плодить промежуточные массивы, есть ленивый модуль 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);

Потоковые filter и map работают на итераторах и останавливают проход сразу после того, как take(5) наберёт пять подходящих заказов, а toArray собирает только их.

На фоне lodash/fp и Ramda, строившихся под динамический JS, fp-pack выигрывает предсказуемым автодополнением в TypeScript, а fp-ts уступает по академической глубине, но побеждает по простоте входа. Внутри npm-пакета даже лежат готовые навыки и аддон для кодинг-агентов, чтобы ИИ-ассистенты сразу генерировали цепочки на pipe и SideEffect.

Учитывай два ограничения: ветка 0.16.0 ещё до релиза 1.0, поэтому автор периодически уточняет типы и убирает старые алиасы, а интерактивная песочница на GitHub Pages изначально сделана с корейским интерфейсом при английской документации. Если тебя интересует строгая типизация без лишнего веса в рантайме, загляни в наш разбор gdp-ts с формальными доказательствами в типах и заметку о сокращении объёма JavaScript-бандлов.

Не нужно в один вечер переписывать весь проект на чистые функции и учить теорию категорий. Возьми одну самую запутанную цепочку разбора массивов или ответов API, собери её в линейный pipe и подключай pipeSideEffect или fp-pack/stream только там, где действительно нужен ранний выход или ленивый проход.

Хочу подробный разборГолоса помогают выбрать, что разобрать подробно. За этот материал 0 голосов.
Источники · 2