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

Однако мы здесь не ради восхваления Haskell, а чтобы улучшить навыки работы с языком С++. Он позволяет написать аналогичный код. Мы не сможем достичь того же уровня элегантности, какой видели в языке Haskell, зато у нас под рукой самый быстрый язык программирования. В этом разделе показано, как инициировать конкатенацию функций в С++ с помощью лямбда-выражений.

Как это делается

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

1. Сначала включим несколько заголовочных файлов:

#include <iostream>

#include <functional>

2. Далее реализуем вспомогательную функцию concat, которая принимает множество параметров. Таковыми выступят функции наподобие f, g и h, а результатом будет еще один объект функции, применяющий функции f(g(h(...))) для любых входных данных.

template <typename T, typename ...Ts>

auto concat(T t, Ts ...ts)

{

3. Теперь задача усложняется. Когда пользователь предоставит функции f, g и h, мы оценим это выражение как f(concat(g, h)), которое будет распаковано в f(g(concat(h))), на чем рекурсия остановится, и мы получим выражение f(g(h(...))). Данная цепочка вызовов функций, представляющая конкатенацию пользовательских функций, захватывается лямбда-выражением, которое затем может принять какие-то параметры p и передать в вызов f(g(h(p))). Мы будем возвращать это лямбда-выражение. Конструкция if constexpr проверяет, находимся ли мы на шаге рекурсии, требующем сконкатенировать более чем одну функцию:

  if constexpr (sizeof...(ts) > 0) {

    return [=](auto ...parameters) {

      return t(concat(ts...)(parameters...));

    };

  }

4. Еще одна ветвь конструкции if constexpr будет выбрана компилятором в том случае, если достигнут конец рекурсии. В таких ситуациях просто возвращаем функцию, t, поскольку она является единственным оставшимся параметром:

  else {

    return t;

  }

}

5. Теперь применим нашу новую функцию конкатенации, передав в нее несколько функций. Начнем с функции main, где определим два дешевых объекта функций:

int main()

{

  auto twice ([] (int i) { return i * 2; });

  auto thrice ([] (int i) { return i * 3; });

6. Выполним конкатенацию. Объединим два объекта функций умножения с помощью функции STL std::plus<int>, которая принимает два параметра и возвращает их сумму. Таким образом, получим функцию, выполняющую вызов twice(thrice(plus(a, b ))).

  auto combined (

    concat(twice, thrice, std::plus<int>{})

  );

7. Воспользуемся тем, что получилось. Функция combined теперь выглядит как обычная, и компилятор может объединять эти функции без особых задержек:

  std::cout << combined(2, 3) << 'n';

}

8. Компиляция и запуск программы дадут следующий результат, и он не будет неожиданным, поскольку 2*3*(2+3) равно 30:

$ ./concatenation

30

Как это работает 

Самой сложной частью этого раздела является функция concat. Она выглядит очень мудреной, поскольку разворачивает набор параметров ts в другое лямбда-выражение, которое рекурсивно снова вызывает функцию concat, теперь уже с меньшим количеством параметров:

template <typename T, typename Ts>

auto concat(T t, Ts ts)

{

  if constexpr (sizeof...(ts) > 0) {

    return [=](auto ...parameters) {

      return t(concat(ts...)(parameters...));

    };

  } else {

    return [=](auto ...parameters) {

      return t(parameters...);

    };

  }

}

Напишем более простую версию этой функции, которая объединяет ровно три функции:

template <typename F, typename G, typename H>

auto concat(F f, G g, H h)

{

  return [=](auto ... params) {

    return f(g(h(params...)));

  };

}

Эта функция выглядит аналогично, но уже не так сложна. Мы возвращаем лямбда-выражение, которое захватывает f, g и h. Оно принимает произвольно большое количество параметров и просто перенаправляет их по цепочке вызовов f, g и h. Если мы пользуемся конструкцией auto combined(concat(f,g,h)), а затем вызываем данный объект функции с двумя параметрами, например combined(2,3), то 2, 3 представлены набором параметров из предыдущей функции concat.

Повторный взгляд на гораздо более сложную обобщенную функцию concat позволяет увидеть следующее: единственное, что мы действительно делаем по-другому, — выполняем конкатенацию f(g(h(params...))). Вместо этого мы пишем выражение f(concat(g,h))(params...), которое будет преобразовано в конструкцию f(g(concat(h)))(params...) при следующем рекурсивном вызове, а затем — в конструкцию f(g(h(params...))). 

Создаем сложные предикаты с помощью логической конъюнкции

При фильтрации данных с помощью обобщенного кода мы определяем предикаты, которые указывают, какие именно данные нужны. Иногда предикаты являются комбинациями нескольких «собратьев».

При фильтрации строк, например, можно реализовать предикат, который возвращает значение true, если входная строка начинается со слова "foo". Еще один предикат должен возвращать значение true, если входная строка заканчивается словом "bar".

Вместо того чтобы постоянно писать собственные предикаты, можно повторно использовать предикаты, объединив их. Для фильтрации строк, которые начинаются со слова "foo" и заканчиваются словом "bar", можно просто выбрать уже существующие предикаты и объединить их с помощью логического И. В данном разделе мы будем работать с лямбда-выражениями, чтобы найти удобный способ сделать это.

Как это делается

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

1. Как обычно, сначала включим несколько заголовочных файлов:

#include <iostream>

#include <functional>

#include <string>

#include <iterator>

#include <algorithm>

2. Поскольку они понадобятся нам в дальнейшем, реализуем две простые функции-предиката. Одна из них говорит о том, начинается ли строка с символа 'a', а вторая — заканчивается ли строка символом 'b':

static bool begins_with_a (const std::string &s)

{

  return s.find("a") ==