re:re:actable
Урок 053 минуты чтения

Задача: compose и pipe

На этой странице
Кратко

compose(f, g, h)(x) вычисляет f(g(h(x))) — функции применяются справа налево. pipe(f, g, h)(x) вычисляет h(g(f(x))) — слева направо, как читается. Обе реализуются одной строкой через reduce / reduceRight. Частые продолжения задачи: асинхронный pipeAsync для функций, возвращающих промисы, и цепочка middleware.

Вопрос

Реализуйте compose и pipe. Чем они отличаются? Как сделать вариант для асинхронных функций?

Решение

const pipe = (...fns) => (input) => fns.reduce((acc, fn) => fn(acc), input);
 
const compose = (...fns) => (input) => fns.reduceRight((acc, fn) => fn(acc), input);

Если первая функция должна принимать несколько аргументов:

const pipe = (first, ...rest) => (...args) => rest.reduce((acc, fn) => fn(acc), first(...args));

Проверка

const trim = (s) => s.trim();
const lower = (s) => s.toLowerCase();
const slugify = (s) => s.replace(/\s+/g, "-");
 
const toSlug = pipe(trim, lower, slugify);
toSlug("  Hello World  ");          // "hello-world"
 
const toSlug2 = compose(slugify, lower, trim);
toSlug2("  Hello World  ");         // "hello-world"
 
pipe()(5);                          // 5 — без функций возвращает вход

Асинхронный pipe

const pipeAsync = (...fns) => (input) =>
  fns.reduce((acc, fn) => acc.then(fn), Promise.resolve(input));
 
const loadUser = async (id) => ({ id, name: "Анна" });
const addAvatar = async (user) => ({ ...user, avatar: `/avatars/${user.id}.png` });
const toView = (user) => `${user.name} (${user.avatar})`;
 
await pipeAsync(loadUser, addAvatar, toView)(7);
// "Анна (/avatars/7.png)"

acc.then(fn) работает и с синхронными, и с асинхронными функциями.

Цепочка middleware (продолжение задачи)

function createPipeline(middlewares) {
  return function run(ctx) {
    let index = -1;
    function dispatch(i) {
      if (i <= index) return Promise.reject(new Error("next() вызван дважды"));
      index = i;
      const mw = middlewares[i];
      if (!mw) return Promise.resolve();
      return Promise.resolve(mw(ctx, () => dispatch(i + 1)));
    }
    return dispatch(0);
  };
}
 
const run = createPipeline([
  async (ctx, next) => { ctx.log.push("a1"); await next(); ctx.log.push("a2"); },
  async (ctx, next) => { ctx.log.push("b"); await next(); },
]);
 
const ctx = { log: [] };
await run(ctx);
ctx.log;   // ["a1", "b", "a2"] — модель «луковицы», как в Koa

Доп. вопросы интервьюера

  • Чем compose отличается от pipe? только направлением применения.
  • Где используется? функциональное программирование, Redux compose для enhancers, middleware, трансформации данных.
  • Как отлаживать цепочку? вставить tap: const tap = (fn) => (x) => (fn(x), x).

Что важно помнить

Мини-шпаргалка

pipe = (...fns) => x => fns.reduce((a, f) => f(a), x) — слева направо. compose — reduceRight, справа налево. Async: fns.reduce((p, f) => p.then(f), Promise.resolve(x)). Middleware — dispatch(i) с next.

Документация

MDN: Array.prototype.reduce, MDN: Array.prototype.reduceRight, Redux: compose.

Дочитали до конца?
Отметьте урок — прогресс сохранится в браузере.

Поиск

Поиск по урокам