Как часто вам приходилось видеть что-то подобное в коде?

const result = fnD(fnC(fnB(fnA(...))));

Чтобы получить результат, нужно последовательно выполнить каждую функцию, начиная с самой внутренней. Это требует визуального "разворачивания" функций, что усложняет понимание логики кода. Когда мы сталкиваемся с таким кодом, то сразу осознаем, что его чтение и поддержка могут стать настоящим испытанием.

В этой статье мы рассмотрим, как можно значительно улучшить читаемость кода с помощью двух мощных техник: пайплайнинга (pipelining) и композиции функций (composing). Мы будем использовать TypeScript для демонстрации этих подходов.

Начнем с условного примера, который иллюстрирует, как вложенные вызовы могут затруднить восприятие кода:

const add = (a: number, b: number) => a + b;
const square = (x: number) => x * x;
const half = (x: number) => x / 2;
const result = half(square(add(2, 2))); // 8

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

Pipelining

Pipelining — это техника передачи данных через цепочку операций, имеющая корни в математической теории. Результат одной функции передаётся следующей функции, формируя непрерывный поток обработки данных.

Следует учесть, что при объединении нескольких функций в pipeline тип вывода одной функции должен совпадать с типом параметра следующей функции. Создадим вспомогательный тип FnsTypeCheck, который будет проверять, соответствуют ли два типа требуемому условию.

type FN<T = any> = (...args: T[]) => any;

type FnsTypeCheck<FNS extends FN[]> =
  1 extends FNS["length"]
    ? boolean
    : FNS extends [
        infer FN1st extends FN,
        infer FN2nd extends FN,
        ...infer FNRest extends FN[]
      ]
    ? Parameters<FN2nd> extends[ReturnType<FN1st>]
      ? FnsTypeCheck<[FN2nd, ...FNRest]>
      : never
    : never;

Выше приведенный код выполняется рекурсивно. Если в pipline передана только одна функция, то возвращается boolean, указывающий на успешную проверку типов. Если функций больше, сначала проверяется, совпадает ли тип параметра второй функции с типом возвращаемого значения первой функции. Затем рекурсивно проверяется соответствие типов для всех последующих функций. В случае несоответствия типов возвращается never, обозначающее ошибку.

Теперь приступим к написанию типа Pipeline:

type Pipeline<FNS extends FN[]> =
  boolean extends FnsTypeCheck<FNS>
    ?  1 extends FNS["length"]
       ? FNS[0]
       : FNS extends [
           infer FNFIRST extends FN,
           ...FN[],
           infer FNLAST extends FN
         ]
       ? (...args: Parameters<FNFIRST>) => 
         ReturnType<FNLAST>
       : never
    : never;

Сначала мы проверяем корректность типов функций с помощью FnsTypeCheck. Если все типы совпадают, тип pipeline будет корректным. Он будет соответствовать функции, которая принимает аргументы того же типа, что и первая функция в pipeline. Возвращаемое значение будет иметь тот же тип, что и результат последней функции.

Что бы TypeScript смог правильно определить типы используем технику перегрузки.

Реализация c использованием замыкания:

function pipeline<FNS extends FN[]>(...fns: FNS): Pipeline<FNS>;
function pipeline<FNS extends FN[]>(...fns: FNS): FN {
  return (...args: Parameters<FNS[0]>) => {
    let result = fns[0](...args);
    for (let i = 1; i < fns.length; i++) {
      result = fns[i](result);
    }
    return result;
  };
}
pipeline(
	add, 
	square, 
	half
)(2, 2); // 8

Как мы видим, использование pipeline облегчает читаемость кода, т.к. создает линейный поток данных и благодаря этому, устраняет сложную вложенность вызовов функций.

Напишем pipeline с использованием метода reduce:

function pipeline<FNS extends FN[]>(...fns: FNS): Pipeline<FNS>;
function pipeline<FNS extends FN[]>(...fns: FNS) {
  return fns.reduce(
    (prevFn: FN, nextFn: FN) =>
      (...args: Parameters<FNS[0]>) =>
        nextFn(prevFn(...args))
  );
}

Применение метода reduce позволяет написать более элегантную реализацию pipeline.

Composing

Composing, как и pipelining, имеет корни в математической теории.
Это последовательность вызовов функций, в которой выходные данные одной функции становятся входными данными для следующей функции, но в порядке, противоположном тому, который используется в pipelining.

Опираясь на подход, использованный при написании pipeline, типизация данных для compose будет во многом аналогична. Сначала создадим вспомогательный тип ComposeFnsTypeCheck, который проверит правильность сочетания наших функций.

type ComposeFnsTypeCheck<FNS extends FN[]> =
  1 extends FNS["length"]
    ? boolean
    : FNS extends [
        ...infer FNInit extends FN[],
        infer FNPrev extends FN,
        infer FNLast extends FN
      ]
    ? Parameters<FNPrev> extends [ReturnType<FNLast>]
      ? ComposeFnsTypeCheck<[...FNInit, FNPrev]>
      : never
    : never;

Это практически то же самое, что мы сделали для pipeline, за исключением того, что функции обрабатываются в обратном порядке — справа налево. Теперь, когда это завершено, мы можем приступить к написанию типа Compose.

type Compose<FNS extends FN[]> =
  boolean extends ComposeFnsTypeCheck<FNS>
    ? 1 extends FNS["length"]
      ? FNS[0]
      : FNS extends [
          infer FNFIRST extends FN,
          ...FN[],
          infer FNLAST extends FN
        ]
      ? (...args: Parameters<FNLAST>) =>
        ReturnType<FNFIRST>
      : never
    : never;

Теперь мы можем применить написанные типы к compose.

Реализация c использованием замыкания:

function compose<FNS extends FN[]>(...fns: FNS): Compose<FNS>;
function compose<FNS extends FN[]>(...fns: FNS): FN {
  return (...args: Parameters<FNS[0]>) => {
    let result = fns[fns.length - 1](...args);
    for (let i = fns.length - 2; i >= 0; i--) {
      result = fns[i](result);
    }
    return result;
  };
}

Реализация с использованием pipeline:

function compose<FNS extends FN[]>(...fns: FNS): Compose<FNS>;
function compose<FNS extends FN[]>(...fns: FNS) {
  return pipeline(...fns.reverse());
}
compose(
	half, 
	square, 
	add
)(2, 2);  // 8

Заключение:

В статье мы рассмотрели две техники — pipelining и composing.

Pipelining и composing упрощают код, создавая линейные потоки данных, что облегчает понимание последовательности операций и устраняют сложную вложенность вызовов функций.

В pipeline() данные проходят через функции последовательно — от первой к последней,
а в compose() функции применяются в обратном порядке — от последней к первой.

Оба подхода способствуют созданию более ясной структуры кода, что значительно улучшает его читаемость.

Использование типов Pipeline и Compose обеспечивает дополнительный уровень проверки типов.