Пока вы используете Metaparse, вы будете писать парсеры, превращая входной текст в тип. Эти типы могут быть позже обработаны дальнейшими шаблонными метапрограммами. Пока вы работаете над парсерами, вы, вероятно, захотите посмотреть на результат анализа тестового ввода. Этот учебник предполагает, что вы можете использоватьMetashell. Поскольку онлайн-демонстрацияделает заголовки Boost доступными, вы также можете использовать это в учебнике.

Если вы установите Metashell на свой компьютер, убедитесь, что у вас есть библиотеки Boost и пример<getting_started>Metaparse на пути включения. Например, вы можете начать Metashell со следующих аргументов:

$ metashell -I$BOOST_ROOT -I$BOOST_ROOT/libs/metaparse/example/getting_started

<$BOOST_ROOT>относится ккаталогу корней повышения(где вы проверили исходный код Boost).

Этот учебник длинный, и поэтому вы можете сделать более короткие или длинные перерывы во время чтения. Чтобы вам было легко остановиться в определенный момент и продолжить позже (или начать в середине, если вы уже знакомы с основами) Метапарс имеет<getting_started>каталог в<example>с. Это содержит определения для каждого раздела этого учебника.

Если вы собираетесь начать (или продолжить) это руководство из раздела 5.2.1, вы можете включить<5_2_1.hpp>. Это определит все, что вам нужно начать с этого раздела.

	Note
	У вас также есть доступ к этим заголовкам в онлайн-демо Metashell. Например, вы можете включить заголовок<<boost/metaparse/getting_started/5_2_1.hpp>>, чтобы начать с раздела 5.2.1.

Если у вас нет доступа к Metashell или вы предпочитаете использовать обычную среду разработки C++ при обработке этого руководства, это также возможно.

Учебник (и, как правило, эксперименты с Metaparse) требует, чтобы вы оценили различные выражения метапрограммирования шаблонов и проверили их результат. Таким образом, чтобы попробовать примеры этого учебника, вам нужен способ отображения результата оценки метапрограммы шаблона. Этот раздел показывает вам два варианта.

#include <boost/metaparse/string.hpp>
#include <boost/mpl/print.hpp>
boost::mpl::print<BOOST_METAPARSE_STRING("11 + 2")> x;

#include <boost/metaparse/string.hpp>
#include <boost/type_index.hpp>
#include <iostream>
int main()
{
  std::cout
    << boost::typeindex::type_id_with_cvr<BOOST_METAPARSE_STRING("11 + 2")>()
    << std::endl;
}

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

Вы пробовали анализировать недействительный вход? То, что не является числом, например:

> exp_parser1::apply<BOOST_METAPARSE_STRING("thirteen")>::type
<< compilation error >>

Ну,<"thirteen">— эточисло, но наш парсер не говорит по-английски, поэтому он считается недействительным вводом. В результате этого компиляция терпит неудачу, и вы получаете ошибку компиляции от Metashell.

В разделеОбработка недействительных входных данныхмы рассмотрим более подробную информацию об обработке ошибок.

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

Попробуем дать парсеру два числа вместо одного:

> exp_parser1::apply<BOOST_METAPARSE_STRING("11 13")>::type
mpl_::integral_c<int, 11>

Вы можете быть удивлены: парсер не вернул ошибку. Первое число<11>и проигнорировано<13>. Способ работы<int_>заключается в том, что он анализирует число в начале входного текста и игнорирует остальную часть входа.

Так<exp_parser1>имеет ошибку: наш маленький язык состоит изодногочисла, а несписка чисел. Давайте исправим наш парсер, чтобы рассматривать более одного числа как недействительный вход:

> #include <boost/metaparse/entire_input.hpp>

Это дает нам класс шаблонов<entire_input>. Мы можем обернуть<int_><entire_input>, указав, что число, которое мы анализируем<int_>, должно быть всем входом. Все, что происходит после этого, является ошибкой. Так что наш парсер<entire_input><<><int_><>>сейчас. Давайте завернем его<build_parser>:

> using exp_parser2 = build_parser<entire_input<int_>>;

Давайте попробуем новый парсер:

> exp_parser2::apply<BOOST_METAPARSE_STRING("13")>::type
mpl_::integral_c<int, 13>

Он все еще может анализировать числа. Попробуем дать ему два числа:

> exp_parser2::apply<BOOST_METAPARSE_STRING("11 13")>::type
<< compilation error >>

Это порождает ошибку компиляции, так как парсер не справился.

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

Теперь наш парсер стал слишком ограничительным. Он не допускаетничегопосле числа, даже белых пространств:

> exp_parser2::apply<BOOST_METAPARSE_STRING("11 ")>::type
<< compilation error >>

Допустим белые пространства после номера:

> #include <boost/metaparse/token.hpp>

Это делает его<token>Класс шаблонов доступен. Он принимает парсер в качестве аргумента и допускает дополнительные белые пространства после этого. Давайте создадим третий парсер, разрешающий белые пространства после числа:

> using exp_parser3 = build_parser<entire_input<token<int_>>>;

Мы ожидаем, что<token><<><int_><>>в этом случае будет весь вход. После<int_>мы допускаем дополнительные белые пространства, но не более того:

> exp_parser3::apply<BOOST_METAPARSE_STRING("11 ")>::type
mpl_::integral_c<int, 11>

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

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

В нашем последнем решении мы разобрали их, используя<token><<><int_><>>и<token><<><lit_c><<'+'>>>парсеров. Вы заметили какой-то шаблон? Мы заворачиваем парсеры токенов<token><<...>>. Это не просто синтаксический сахар. Наши токены могут быть разделены белыми пространствами, которые можно игнорировать. Это то, что<token><<...>>реализует.

Итак, давайте сделаем реализацию<exp_parser>более чистой, отделив токенизацию от остальной части парсера:

> using int_token = token<int_>;
> using plus_token = token<lit_c<'+'>>;

копипаст-дружественная версия

Эти два определения создают псевдонимы типов для парсеров наших токенов. Для компилятора не имеет значения, используем ли мы<plus_token>или<token><<><lit_c><<'+'>>>, поскольку они относятся к одному и тому же типу. Но это облегчает понимание кода парсера.

Теперь мы можем определить наш парсер выражений, используя эти токены:

> using exp_parser5 = build_parser<sequence<int_token, plus_token, int_token>>;

Мы можем использовать его так же, как<exp_parser4>:

> exp_parser5::apply<BOOST_METAPARSE_STRING("11 + 2")>::type
boost_::mpl::vector<mpl_::integral_c<int, 11>, mpl_::char_<'+'>, mpl_::integral_c<int, 2> >

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

Было бы неплохо, если бы мы также могли оценить выражение. Вместо того, чтобы возвращать а<vector>в результате разбора, мы должны возвращать оцениваемое выражение. Например, результат разбора<"11 + 2">должен быть<mpl_::integral_c<int,13>>.

Metaparse предоставляет<transform>, которые мы можем использовать для реализации этого:

> #include <boost/metaparse/transform.hpp>

Это можно использовать для преобразования результата парсера. Например, у нас есть парсер<sequence><<int_token,plus_token,int_token>>, который возвращает<vector>. Мы хотим превратить это<vector>в число, которое является результатом оценки выражения. Нам нужно передать<transform><sequence><<...>>парсер и функцию, которая превращает<vector>в нужный нам результат. Для начала давайте создадим этуметафункцию:

> #include <boost/mpl/plus.hpp>
> #include <boost/mpl/at.hpp>
> template <class Vector> \
...> struct eval_plus : \
...>   boost::mpl::plus< \
...>     typename boost::mpl::at_c<Vector, 0>::type, \
...>     typename boost::mpl::at_c<Vector, 2>::type \
...>   > {};

копипастная версия

	Note
	Обратите внимание, что если последним персонажем вашей команды является персонаж<\>в Metashell, то оболочка предполагает, что вы продолжите вводить ту же команду и ждете этого, прежде чем оценивать свою команду. Когда Metashell ждет вторую (или третью, или четвертую и т.д.) строку команды, она использует специальную подсказку<...>>.

Используя<boost::mpl::at_c>, он берет первый (индекс 0) и третий (индекс 2) элементы<vector>, что является результатом разбора с<sequence><<...>>и добавляет их. Примером может служить<vector>:

> eval_plus< \
...>  boost::mpl::vector< \
...>    mpl_::integral_c<int, 11>, \
...>    mpl_::char_<'+'>, \
...>    mpl_::integral_c<int, 2> \
...>  >>::type
mpl_::integral_c<int, 13>

копипастная версия

Мы можем использовать<eval_plus>для построения парсера, который оценивает выражение, которое он парсирует:

> #include <boost/mpl/quote.hpp>
> using exp_parser6 = \
...> build_parser< \
...>   transform< \
...>     sequence<int_token, plus_token, int_token>, \
...>     boost::mpl::quote1<eval_plus> \
...>   > \
...> >;

копипастный дружественный вариант

	Note
	Обратите внимание, что мы должны использовать<boost::mpl::quote1>, чтобы превратить нашу<eval_plus>метафункциювкласс метафункций.

<transform>анализирует вход с использованием<sequence><<int_token,plus_token,int_token>>и преобразует результат этого с использованием<eval_plus>. Давайте попробуем:

> exp_parser6::apply<BOOST_METAPARSE_STRING("11 + 2")>::type
mpl_::integral_c<int, 13>

Мы создали простое выражение parser. Следующая диаграмма показывает, как это работает:

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

Он использует<sequence>для разбора различных элементов (первое число, символ<+>и второе число) и строит<vector>. Окончательный результат рассчитывается из этого<vector>парсером<transform>.

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

Мы не можем решить эту проблему с<sequence>, поскольку мы не знаем, сколько чисел будет иметь вход. Нам нужен парсер, который:

Парсирование первого числа — это то, что мы уже можем сделать: парсер<int_token>делает это за нас. Сравнение<+<number>>элементов более сложное. Metaparse предлагает различные инструменты для этого. Самый простой из них<repeated>:

> #include <boost/metaparse/any.hpp>

<repeated>нужен парсер (который анализирует один<+ <number>>элемент), и он продолжает анализировать вход с ним, насколько это возможно. Для нас это будет означать весь вклад. Давайте создадим парсер для наших выражений, используя его:

> using exp_parser7 = \
...> build_parser< \
...>   sequence< \
...>     int_token,                                /* The first <number> */ \
...>     repeated<sequence<plus_token, int_token>> /* The "+ <number>" elements */ \
...>   > \
...> >;

копипастная версия

У нас есть<sequence>с двумя элементами:

Вторая часть представляет собой<repeated>, который анализирует<+<number>>элементы. Один такой элемент разбирается<sequence><<plus_token, int_token>>. Это просто последовательность символа<+>и числа.

Давайте попробуем разобрать выражение, используя это:

> exp_parser7::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type

Вот отформатированная версия результата, которую легче прочитать:

boost_::mpl::vector<
  // The result of int_token
  mpl_::integral_c<int, 1>,
  // The result of repeated< sequence<plus_token, int_token> >
  boost_::mpl::vector<
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 2> >,
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 3> >,
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 4> >
  >
>

В результате получается<vector>из двух элементов. Первый элемент этого<vector>является результатом разбора входа с<int_token>, второй элемент этого<vector>является результатом разбора входа с<repeated><< ><sequence><<plus_token,int_token>>>. Вторым элементом является<vector>. Каждый элемент этого<vector>является результатом разбора входа с<sequence><<plus_token,int_token>>один раз. Вот диаграмма, показывающая, как<exp_parser7>парсирует вход<1+ 2+3+4>:

Диаграмма показывает, что<+<number>>элементы парсируются<sequence><<plus_token, int_token>>элементов, и их результаты собираются<repeated>, который конструирует<vector>этих результатов. Значение первого<<number>>и этого<vector>помещаются в другое<vector>, которое является результатом разбора.

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

Конечным результатом здесь является пара первого числа и<vector>остальных значений. Чтобы вычислить результат, нам нужно обработать эту структуру данных. Давайте приведем пример, который мы только что рассмотрели. Это облегчит тестирование кода, вычисляющего конечный результат из этой структуры:

> using temp_result = exp_parser7::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type;

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

5.2.1. Learning about boost::mpl::fold

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

У нас есть<vector>, содержащий еще<vector>. Поэтому нам нужно будет уметь обобщать элементы разных<vector>с. Для этого мы можем использовать<boost::mpl::fold>метафункцию:

> #include <boost/mpl/fold.hpp>

С этойметафункциеймы можем повторить<vector>парсированных чисел и суммировать их. Мы можем предоставить емуметафункцию, принимая два аргумента: сумму, которую мы имеем до сих пор, и следующий элемент<vector>. Этаметафункциябудет востребована для каждого элемента<vector>.

	Note
	Это очень похоже на алгоритм<std::accumulate>.Boost.MPLтакже предоставляет<boost::mpl::accumulate>, что является синонимом<boost::mpl::fold>. Этот учебник (и Metaparse) использует имя<fold>.

Начнем с простого случая:<vector>чисел. Рассмотрим, например, следующие элементы<vector>:

> using vector_of_numbers = \
...> boost::mpl::vector< \
...>   boost::mpl::int_<2>, \
...>   boost::mpl::int_<5>, \
...>   boost::mpl::int_<6> \
...> >;

дружественная к копированию версия

Мы напишемшаблон метафункции,<sum_vector>для суммирования элементов<vector>чисел:

> template <class Vector> \
...> struct sum_vector : \
...>    boost::mpl::fold< \
...>      Vector, \
...>      boost::mpl::int_<0>, \
...>      boost::mpl::lambda< \
...>        boost::mpl::plus<boost::mpl::_1, boost::mpl::_2> \
...>      >::type \
...>    > \
...>  {};

копипастная версия

Этаметафункцияиспользует<vector>для обобщения элементов в качестве аргумента и использует<boost::mpl::fold>для вычисления суммы.<boost::mpl::fold>использует три аргумента:

• Контейнер для подведения итогов. Это<Vector>.
• Начальное значение длясуммы, которую мы имеем до сих пор. Использование<0>означает, что мы хотим начать сумму с<0>.
• Функция вызова в каждой итерации при зацикливании над контейнером. В нашем примере мы используем выражениелямбда, которое является выражением, обернутым<boost::mpl::lambda>. Это выражение объединяет два аргумента<boost::mpl::plus>. Выражение лямбда относится к его аргументам<boost::mpl::_1>и<boost::mpl::_2>.

Давайте попробуем этуметафункцию:

> sum_vector<vector_of_numbers>::type
mpl_::integral_c<int, 13>

Работает, как и ожидалось. Вот диаграмма, показывающая, как это работает:

Как показано на диаграмме,<boost::mpl::fold>оценивает выражение лямбда для каждого элемента<vector>и передает результат предыдущей оценки следующему вызову выражения лямбда.

У нас естьметафункция, которая может суммировать<vector>чисел. Результатом разбора<+<number>>элементов является<vector>из<vector>с. В качестве примера можно привести<temp_result>:

boost_::mpl::vector<
  // The result of int_token
  mpl_::integral_c<int, 1>,
  // The result of repeated< sequence<plus_token, int_token> >
  boost_::mpl::vector<
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 2> >,
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 3> >,
    boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 4> >
  >
>

Сначала подведем итоги<repeated><<...>>с использованием<boost::mpl::fold>. Это<vector>из<vector>, но это нормально.<boost::mpl::fold>не заботится о том, каковы элементы<vector>. Они могут быть числами<vector>или чем-то еще. Функция, которую мы используем, чтобы сложить два числа вместе (что было выражением лямбда в нашем предыдущем примере), получает эти элементы в качестве аргумента и имеет дело с ними. Таким образом, чтобы обобщить элементы<vector>s, которые мы получаем в результате разбора с<repeated><<...>>, нам нужно написатьметафункцию, которая может иметь дело с этими элементами. Одним из таких элементов является<boost_::mpl::vector<mpl_::char<'+'>, mpl_::integral_c<int,2>>>. Вотметафункция, которую можно использовать в<boost::mpl::fold>:

> template <class Sum, class Item> \
...>   struct sum_items : \
...>     boost::mpl::plus< \
...>       Sum, \
...>       typename boost::mpl::at_c<Item, 1>::type \
...>     > \
...> {};

дружественная версия

Эта функция принимает два аргумента:

• <Sum>, что является числом. Это краткое изложение уже обработанных элементов.
• <Item>, следующий пункт<vector>. Эти элементы имеют размер<vector>с два: результат разбора символа<+>и числа.

Метафункциядобавляет сумму, которую мы имеем до сих пор, и следующее число вместе, используя<boost::mpl::plus>.метафункция. Чтобы получить следующий номер из<Item>, он использует<boost::mpl::at_c>. Попробуем<sum_items>:

> sum_items< \
...>   mpl_::integral_c<int, 1>, \
...>   boost::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 2>> \
...> >::type
mpl_::integral_c<int, 3>

дружественная версия

Мы позвонили<sum_items>со значениями<temp_result>и увидели, что он работает так, как ожидалось: он добавил частичную сумму<mpl_::integral_c<int,1>>к следующему числу<mpl_::integral_c<int,2>>.

<boost::mpl::fold>может суммировать список, который мы получаем в результате разбора<+ <number>>элементов ввода, поэтому нам нужно сначала извлечь этот список из<temp_result>:

> boost::mpl::at_c<temp_result, 1>::type

Вот отформатированная версия результата:

boost_::mpl::vector<
  boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 2>>,
  boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 3>>,
  boost_::mpl::vector<mpl_::char_<'+'>, mpl_::integral_c<int, 4>>
>

Это второй элемент вектора<temp_result>(первый — значение первого элемента<<number>>). Давайте попробуем сложить для этого:

> \
...> boost::mpl::fold< \
...>   boost::mpl::at_c<temp_result, 1>::type, /* The vector to summarise */ \
...>   boost::mpl::int_<0>, /* The value to start the sum from */ \
...>   boost::mpl::quote2<sum_items> /* The function to call in each iteration */ \
...> >::type
mpl_::integral_c<int, 9>

копипастная версия

	Note
	Мы используем<sum_items>в качестве функции вызова в каждой итерации. Мы передаемметафункцию<sum_items>другомуметафункцию<boost::mpl::fold>в качестве аргумента. Чтобы сделать это, нам нужно превратить его в класс метафункцийшаблона, используя<boost::mpl::quote2><2>.

Как мы видели, результатом этого является сумма элементов, которая была<9>в нашем случае. Вот диаграмма, показывающая, как работает<boost::mpl::fold>:

Он начинается со значения<boost::mpl::int_<0>>и добавляет элементы<boost_::mpl::vector>, содержащие результаты разбора один за другим. Диаграмма показывает, как подрезультаты рассчитываются, а затем используются для дальнейших расчетов.

5.2.2. Evaluating the expression using boost::mpl::fold

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

Давайте использовать<sum_items>с<boost::mpl::fold>для построения парсера, который суммирует значения, исходящие от<+<number>>элементов. Мы можем расширить парсер, который мы использовали в<exp_parser7>, обернув<repeated><<...>>часть<transform>, что преобразует результат<repeated><<...>>с помощью только что созданной нами складывающейся экспрессии:

> using exp_parser8 = \
...> build_parser< \
...>   sequence< \
...>     int_token, /* parse the first <number> */ \
...>     transform< \
...>       repeated<sequence<plus_token, int_token>>, /* parse the "+ <number>" elements */ \
...> \
...>       /* lambda expression summarising the "+ <number>" elements using fold */ \
...>       boost::mpl::lambda< \
...>         /* The folding expression we have just created */ \
...>         boost::mpl::fold< \
...>           boost::mpl::_1, /* the argument of the lambda expression, the result */ \
...>                           /* of the repeated<...> parser */ \
...>           boost::mpl::int_<0>, \
...>           boost::mpl::quote2<sum_items> \
...>         > \
...>       >::type \
...>     > \
...>   > \
...> >;

дружественная версия

Он использует<transform>, чтобы превратить результат предыдущей версии нашего парсера в тот, который суммирует элементы<+<number>>. Давайте попробуем:

> exp_parser8::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type
boost_::mpl::vector<mpl_::integral_c<int, 1>, mpl_::integral_c<int, 9> >

Это возвращает пару чисел в результате разбора: первое число и сумму остальных. Чтобы получить значение всего выражения, нужно сложить эти два числа вместе. Мы можем расширить наш парсер, чтобы сделать это последнее дополнение:

> using exp_parser9 = \
...> build_parser< \
...>   transform< \
...>     /* What we had so far */ \
...>     sequence< \
...>       int_token, \
...>       transform< \
...>         repeated<sequence<plus_token, int_token>>, \
...>         boost::mpl::lambda< \
...>           boost::mpl::fold< \
...>             boost::mpl::_1, \
...>             boost::mpl::int_<0>, \
...>             boost::mpl::quote2<sum_items> \
...>           > \
...>         >::type \
...>       > \
...>     >, \
...>     boost::mpl::quote1<sum_vector> /* summarise the vector of numbers */ \
...>   > \
...> >;

дружественная версия

<exp_parser9>заворачивает парсер, который мы имели до сих пор (что дает нам два элемента<vector>в результате) с<transform>, чтобы добавить элементы этих двух элементов<vector>вместе. Поскольку два элемента<vector>являются<vector>числами, мы можем (повторно) использовать для этого<sum_vector>метафункцию. Давайте попробуем:

> exp_parser9::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type
mpl_::integral_c<int, 10>

Это дает нам правильный результат, но это очень неэффективно. Давайте посмотрим, почему:

В этом процессе есть два цикла:

• Первый<repeated>петли над входом для разбора всех<+ <number>>элементов. В этом случае<vector>.<Loop1>на рисунке
• <boost::mpl::fold>зацикливается на этом<vector>, чтобы суммировать элементы.<Loop2>на рисунке

	Note
	Обратите внимание, что мы говорим опетле, в то время как в метапрограммировании шаблонов нет такой вещи, как петля. Петли могут быть реализованы с использованиемрекурсии: Каждый рекурсивный вызов является одной итерацией цикла. Петля останавливается в нижней части рекурсивной цепи.

5.2.3. Using a folding parser combinator

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

Было бы неплохо, если бы две петли можно было слить воедино и временный<vector>не пришлось бы строить посередине (не забывайте: нет такой вещи, каксборщик мусорадля шаблонного метапрограммирования). Как только вы создадите шаблон, он будет доступен до конца ... компиляции.

Метапарс обеспечивает<foldl>парсерный комбинатор:

> #include <boost/metaparse/foldl.hpp>

Это почти то же самое, что<boost::mpl::fold>, но вместо того, чтобы принять<vector>в качестве первого аргумента, который исходил из повторного применения парсера<sequence><<plus_token,int_token>>на входе, он принимает сам парсер.<foldl>парсирует вход и вычисляет сводку на лету. Вот как мы можем написать наш парсер, используя его:

> using exp_parser10 = \
...> build_parser< \
...>   transform< \
...>     sequence< \
...>       int_token, \
...>       foldl< \
...>         sequence<plus_token, int_token>, \
...>         boost::mpl::int_<0>, \
...>         boost::mpl::quote2<sum_items> \
...>       > \
...>     >, \
...>     boost::mpl::quote1<sum_vector>> \
...> >;

копипаст-дружественная версия

Ниже представлены форматированные версии<exp_parser9>и<exp_parser10>бок о бок:

//            exp_parser9                                       exp_parser10
build_parser<                                       build_parser<
  transform<                                          transform<
    sequence<                                           sequence<
      int_token,                                          int_token,
      transform<                                          foldl<
        repeated<sequence<plus_token, int_token>>,          sequence<plus_token, int_token>,
        boost::mpl::lambda<
          boost::mpl::fold<
            boost::mpl::_1,
            boost::mpl::int_<0>,                            boost::mpl::int_<0>,
            boost::mpl::quote2<sum_items>                   boost::mpl::quote2<sum_items>
          >
        >::type
      >                                                   >
    >,                                                  >,
    boost::mpl::quote1<sum_vector>                      boost::mpl::quote1<sum_vector>
  >                                                   >
>                                                   >

копипаст-дружественная версия

В<exp_parser10>"_<repeated>, а затем<transform>с<boost::mpl::fold>_" часть (средний блок<exp_parser9>) была заменена одним<foldl>парсером, который делает то же самое, но без построения<vector>в середине. Можно использовать то же начальное значение<boost::mpl::int_<0>>и функцию обратного вызова<sum_items>.

Вот диаграмма, показывающая, как работает<exp_parser10>:

В этом случае результаты парсеров<sequence><<plus_token, int_token>>передаются непосредственно алгоритму складывания без промежуточного<vector>. Вот диаграмма, показывающая<exp_parser9>и<exp_parser10>бок о бок, чтобы было легче увидеть разницу:

5.2.4. Processing the initial element with the folding parser combinator

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

Это решение все еще можно улучшить.<foldl>суммирование элементов<+<number>>начинается с<0>, и как только это будет сделано, мы добавим значение первого<<number>>входа к нему в первой итерации. Было бы проще, если бы<foldl>могли использовать значение первого<<number>>в качестве начального значения суммы, которую мы имеем до сих пор. Метапарс предоставляет<foldl_start_with_parser>для этого:

> #include <boost/metaparse/foldl_start_with_parser.hpp>

<foldl_start_with_parser>почти то же самое, что<foldl>. Разница в том, что вместо начальногозначениядля суммы требуетсяпарсер. Сначала он парсирует вход с этим парсером и использует значение, которое он возвращает в качестве начального значения. Вот как мы можем реализовать наш парсер, используя его:

> using exp_parser11 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<plus_token, int_token>, /* apply this parser repeatedly */ \
...>     int_token, /* use this parser to get the initial value */ \
...>     boost::mpl::quote2<sum_items> /* use this function to add a new value to the summary */ \
...>   > \
...> >;

копипастная версия

Эта версия<exp_parser>использует<foldl_start_with_parser>. Эта реализация более компактна, чем предыдущие версии. В этом нет<sequence>элемента: первый<<number>>разбирается<int_token>и его значение используется в качестве начального значения для резюме. Давайте попробуем:

> exp_parser11::apply<BOOST_METAPARSE_STRING("1 + 2 + 3 + 4")>::type
mpl_::integral_c<int, 10>

Он возвращает тот же результат, что и предыдущая версия, но работает по-другому. Вот диаграмма, показывающая, как работает эта реализация:

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

В настоящее время мы используем<plus_token>для разбора оператора, который должен быть<+>. Мы можем определить новый токен для разбора символа<->:

> using minus_token = token<lit_c<'-'>>;

Мы должны построить парсер, который принимает символ<+>или<->. Это может быть реализовано с помощью<one_of>:

> #include <boost/metaparse/one_of.hpp>

<one_of><<plus_token,minus_token>>является парсером, который принимает либо<+>(с использованием<plus_token>), либо<->(с использованием<minus_token>) символ. Результатом анализа является результат успешного парсера.

	Note
	Вы можете дать любой парсер<one_of>, поэтому возможно, что более одного из них может разобрать вход. В этих случаях порядок имеет значение:<one_of>пытается сравнять вход с парсерами слева направо, и первый, который преуспевает, выигрывает.

Используя это, мы можем заставить наш парсер принимать вычитания:

> using exp_parser12 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token>, int_token>, \
...>     int_token, \
...>     boost::mpl::quote2<sum_items> \
...>   > \
...> >;

копипаст-дружественная версия

Он использует<one_of><<plus_token,minus_token>>в качестве разделителя для чисел. Давайте попробуем:

> exp_parser12::apply<BOOST_METAPARSE_STRING("1 + 2 - 3")>::type
mpl_::integral_c<int, 6>

Результат неправильный. Причина этого в том, что<sum_items>функция, которую мы суммируем, игнорирует, какой оператор использовался, и предполагает, что он всегда<+>.

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

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

Прежде всего нам понадобится<boost::mpl::minus>метафункциядля осуществления вычитания:

> #include <boost/mpl/minus.hpp>

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

> template <class L, char Op, class R> struct eval_binary_op;
> template <class L, class R> struct eval_binary_op<L, '+', R> : boost::mpl::plus<L, R>::type {};
> template <class L, class R> struct eval_binary_op<L, '-', R> : boost::mpl::minus<L, R>::type {};

копипаст-дружественная версия

Первая команда объявляет метафункцию<eval_binary_op>. Первый и третий аргументы — это левый и правый операнды, а второй — оператор.

	Note
	Обратите внимание, что он не удовлетворяет ожиданиям метафункции шаблона, поскольку он принимает оператора как<char>, а не как<class>(или<typename>) аргумент. Для простоты мы все равно назовем его метафункцией.

Вторая и третья команды определяют операцию для случаев, когда оператором является<+>и<->. Когда называется метафункция<eval_binary_op>, компилятор C++ выбирает одно из определений на основе оператора. Если у вас есть опыт функционального программирования, этот подход может быть вам знаком. Попробуем<eval_binary_op>:

> eval_binary_op<boost::mpl::int_<11>, '+', boost::mpl::int_<2>>::type
mpl_::integral_c<int, 13>
> eval_binary_op<boost::mpl::int_<13>, '-', boost::mpl::int_<2>>::type
mpl_::integral_c<int, 11>

копипаст-дружественная версия

Вы также можете попробовать использовать его с оператором, которого он не ожидает. Например,<'*'>. Вы увидите, что компилятор C++ жалуется на то, что запрошенная версия шаблона<eval_binary_op>не была определена. Это решение может быть расширено, и поддержка оператора<'*'>всегда может быть добавлена позже.

Давайте напишем метафункцию, которую мы можем использовать из парсера складывания для оценки выражений с помощью операторов<+>и<->. Это требует двух аргументов:

Давайте напишем метафункцию<binary_op>, которая принимает эти аргументы и вызывает<eval_binary_op>:

> template <class S, class Item> \
...> struct binary_op : \
...>   eval_binary_op< \
...>     S, \
...>     boost::mpl::at_c<Item, 0>::type::value, \
...>     typename boost::mpl::at_c<Item, 1>::type \
...>   > \
...>   {};

копипаст-дружественная версия

Этаметафункцияберет оператор (первый элемент) и правый операнд (второй элемент) из<Item>. Оператор — класс, представляющий символ, такой как<mpl_::char_<'+'>>. Чтобы получить значение символа, нужно получить доступ к его<::value>. Например,<mpl_::char<'+'>::value>—<'+'>. Поскольку<eval_binary_op>принимает это значение символа в качестве второго аргумента, мы должны были передать<boost::mpl::at_c<Item,0>::type::value>ему. Давайте попробуем:

> binary_op<boost::mpl::int_<11>, boost::mpl::vector<boost::mpl::char_<'+'>, boost::mpl::int_<2>>>::type
mpl_::integral_c<int, 13>

Мы передали ему число (805) и<vector>символа (807) и другое число (808). Они добавили две цифры, как и ожидалось. Давайте использовать эту функцию в качестве третьего аргумента<foldl_start_with_parser>:

> using exp_parser13 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token>, int_token>, \
...>     int_token, \
...>     boost::mpl::quote2<binary_op> \
...>   > \
...> >;

копипаст-дружественная версия

Вместо<binary_op>используется<sum_items>. Давайте попробуем:

> exp_parser13::apply<BOOST_METAPARSE_STRING("1 + 2 - 3")>::type
mpl_::integral_c<int, 0>

Это возвращает правильный результат.

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

Мы можем расширить решение, которое мы создали для сложения и вычитания. Для этого нужно добавить поддержку умножения<eval_binary_op>:

> #include <boost/mpl/times.hpp>
> template <class L, class R> struct eval_binary_op<L, '*', R> : boost::mpl::times<L, R>::type {};

копипаст-дружественная версия

Мы должны были включить<<boost/mpl/times.hpp>>, чтобы получить<boost::mpl::times>метафункцию, а затем мы могли бы расширить<eval_binary_op>, чтобы поддержать<*>оператора. Мы можем попробовать:

> eval_binary_op<boost::mpl::int_<3>, '*', boost::mpl::int_<4>>::type
mpl_::integral_c<int, 12>

Это работает, как и ожидалось. Давайте создадим токен для разбора символа<*>:

> using times_token = token<lit_c<'*'>>;

Теперь мы можем расширить наш парсер, чтобы принять символ<*>в качестве оператора:

> using exp_parser14 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token, times_token>, int_token>, \
...>     int_token, \
...>     boost::mpl::quote2<binary_op> \
...>   > \
...> >;

копипаст-дружественная версия

Эта версия принимает в качестве оператора символ<+>,<->или<*>. Давайте попробуем это:

> exp_parser14::apply<BOOST_METAPARSE_STRING("2 * 3")>::type
mpl_::integral_c<int, 6>

Это работает, как и ожидалось. Давайте попробуем другое, чуть более сложное выражение:

> exp_parser14::apply<BOOST_METAPARSE_STRING("1 + 2 * 3")>::type
mpl_::integral_c<int, 9>

Это возвращает неправильный результат. Значение этого выражения должно быть<7>, а не<9>. Проблема в том, что наша текущая реализация не учитывает приоритет оператора. Оно рассматривает это выражение как<(1+ 2)*3>, тогда как мы ожидаем, что оно будет<1+ (2*3)>, поскольку сложение имеет более высокий приоритет, чем умножение.

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

Давайте сделаем так, чтобы у разных операторов был разный приоритет. Для этого мы определяем новый парсер для разбора выражений, содержащих только операторы<*>(то есть оператор с наименьшим приоритетом):

> using mult_exp1 = foldl_start_with_parser<sequence<times_token, int_token>, int_token, boost::mpl::quote2<binary_op>>;

<mult_exp1>может анализировать выражения, содержащие только<*>оператора. Например,<3* 2>или<6 *7*8>. Теперь мы можем создать парсер, поддерживающий только операторов<+>и<->, но вместо разделения чиселс этими операторами мы разделим выражения, содержащие только операторов<*>. Это означает, что выражение<1 *2+3* 4>интерпретируется как выражения<1* 2>и<3 *4>, разделенные оператором<+>. Число (например,<13>) является особым случаем выражения, содержащего только<*>операторов.

Вот парсер, реализующий это:

> using exp_parser15 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token>, mult_exp1>, \
...>     mult_exp1, \
...>     boost::mpl::quote2<binary_op> \
...>   > \
...> >;

дружественная к копированию версия

Это почти то же самое, что<exp_parser13>. Разница лишь в том, что он использует<mult_exp1>везде, где<exp_parser13>использовал<int_token>. Давайте попробуем:

> exp_parser15::apply<BOOST_METAPARSE_STRING("1 + 2 * 3")>::type
mpl_::integral_c<int, 7>

При этом учитываются правила приоритета. Следующая диаграмма показывает, как это работает:

Субэкспрессии, использующие только операторы<*>, оцениваются<mult_exp1>и рассматриваются как единичные единицы при интерпретации выражений с использованием операторов<+>и<->. Номера, не окруженные операторами<*>, также рассматриваются как операторы, использующие только<*>(не содержащие операций, но число).

Если вам нужно больше слоев (например, введение оператора<^>), вы можете расширить это решение с помощью дополнительных слоев. Порядок слоев определяет приоритет операторов.

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

Вот диаграмма, показывающая, как наш текущий парсер обрабатывает выражение<8/ 4/2>:

Он берет первое число<8>, делит его на второе<4>, а затем делит результат на третье<2>. Это означает, что в нашей нынешней реализации разделение остается ассоциативным:<8/ 4/2>означает<(8/4)/2>.

Следует также отметить, что начальное значение<8>и список значений<foldl>итерирует значение</4>,</ 2>.

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

<foldl>многократно применяет парсер и повторяет результаты разбораслевасправа. (Вот откуда взялось имя<l>). Метапарза обеспечивает другой складывающийся парсерный комбинатор<foldr>. Он также применяет парсер на входе, но он повторяется отсправаслева по результатам.

Подобно<foldl_start_with_parser>, Метапарс также предоставляет<foldr_start_with_parser>. Основное различие между этими двумя решениями<foldl_start_with_parser>и<foldr_start_with-parser>заключается в том, что, хотя<foldl_start_with_parser>рассматриваетпервоечисло как особое,<foldr_start_with_parser>рассматриваетпоследнеечисло как особое. Это может показаться странным, но подумайте об этом: если вы хотите суммировать элементы справа налево, ваше начальное значение должно быть последним элементом, а не первым.

Из-за вышеупомянутой разницы<foldr_start_with_parser>не является заменой<foldl_start_with_parser>. В то время как список значений<foldl>повторяется над «<8>», «</4>», «</2>», список значений<foldlr>должен повторяться над «<2>», «<4/>», «<8/>».

Это означает, что функция, которую мы используем для«добавить»новое значение к уже оцененной части выражения (это было<binary_op>до сих пор), должна быть подготовлена для взятия следующего оператора и операнда в обратном порядке (например, путем взятия «<4/>» вместо «</4>». Для этого мы пишем другуюметафункцию:

> template <class S, class Item> \
...> struct reverse_binary_op : \
...>   eval_binary_op< \
...>     typename boost::mpl::at_c<Item, 0>::type, \
...>     boost::mpl::at_c<Item, 1>::type::value, \
...>     S \
...>   > \
...>   {};

дружественная к копированию версия

Существует несколько различий между<binary_op>и<reverse_binary_op>:

Мы должны включить<foldr_start_with_parser>:

> #include <boost/metaparse/foldr_start_with_parser.hpp>

Мы можем переписать<mult_exp>, используя<foldr_start_with_parser>:

> using mult_exp3 = \
...> foldr_start_with_parser< \
...>   sequence<int_token, one_of<times_token, divides_token>>, /* The parser applied repeatedly */ \
...>   int_token, /* The parser parsing the last number */ \
...>   boost::mpl::quote2<reverse_binary_op> /* The function called for every result */ \
...>                                         /* of applying the above parser */ \
...> >;

копипастный дружественный вариант

Это почти то же самое, что<mult_exp2>, но...

Мы можем создать новую версию<exp_parser>, которая использует<mult_exp3>вместо<mult_exp2>:

> using exp_parser17 = \
...> build_parser< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token>, mult_exp3>, \
...>     mult_exp3, \
...>     boost::mpl::quote2<binary_op> \
...>   > \
...> >;

копипастный дружественный вариант

Единственное различие между<exp_parser17>и предыдущей версией<exp_parser16>заключается в том, что она использует обновленную версию<mult_exp>. Давайте попробуем этот парсер:

> exp_parser17::apply<BOOST_METAPARSE_STRING("8 / 4 / 2")>::type
mpl_::integral_c<int, 4>

Эта версия парсера даетдругойвозможный результат. Тот, который вы получаете, когда деление является правильным ассоциативным, что означает, что вышеупомянутое выражение оценивается как<8 /(4/2)>. Вот диаграмма, показывающая, как работает решение на основе<foldr_start_with_parser>:

Чтобы упростить сравнение двух решений, вот диаграмма, показывающая два подхода бок о бок:

Как мы видели, ассоциативность операторов можно контролировать, выбирая между складными решениями. Складные решения, идущие слева направо, реализуют левую ассоциативность, в то время как решения, идущие справа налево, реализуют правую ассоциативность.

	Note
	Обратите внимание, что складные решения, идущие слева направо, реализованы более эффективным способом, чем складывание справа налево. Поэтому, когда оба решения могут быть использованы, вы должны предпочесть складывание слева направо.

Как улучшить сообщения об ошибках? Давайте посмотрим, что пошло не так в предыдущем случае:

Мы, авторы парсера, знаем: мы ожидаем там первичного выражения. Когда<one_of>терпит неудачу, это означает, что никто не был найден.

Чтобы вернуть пользовательские сообщения об ошибках (например,<missing_primary_expression>) пользователю, мы должны сначала определить эти сообщения об ошибках. Сообщения об ошибках представлены классами с некоторыми требованиями:

Эти классы называютсяпарсинговым сообщением об ошибке. Чтобы упростить реализацию таких классов и затруднить (если не невозможно) выполнение требования, Metaparse предоставляет макрос для определения этих классов. Чтобы получить этот макрос, включите следующий заголовок:

> #include <boost/metaparse/define_error.hpp>

Давайте определимсообщение об ошибке парсинга:

> BOOST_METAPARSE_DEFINE_ERROR(missing_primary_expression, "Missing primary expression");

Это определяет класс, называемый<missing_primary_expression>, представляющий это сообщение об ошибке. Нам нужно сделать так, чтобы наш парсер вернул это сообщение об ошибке, когда<one_of>выйдет из строя.

Давайте сначала определим<plus_exp>и<paren_exp>. Их определение не меняется:

> struct plus_exp3;
> using paren_exp4 = middle_of<lparen_token, plus_exp3, rparen_token>;

копипастная версия

Когда ввод не содержит числа (парсируется<int_token>) и выражения paren (парсируется<paren_exp4>), мы должны вернуть сообщение об ошибке<missing_primary_expression>. Мы можем сделать это, добавив третий парсер к<one_of<int_token,paren_exp4,...>>, который всегда терпит неудачу с этим сообщением об ошибке. Метапарс предоставляет<fail>для этого:

> #include <boost/metaparse/fail.hpp>

Теперь мы можем определить парсер<primary_exp>, используя его:

> using primary_exp3 = one_of<int_token, paren_exp4, fail<missing_primary_expression>>;

Он добавляет<fail><<missing_primary_expression>>к<one_of>в качестве последнего элемента. Поэтому, если ни один из «реальных» случаев не анализирует вводи, ни один из них не делает никакого прогресса до отказа, сообщение об ошибке будет<missing_primary_expression>.

Нам нужно определить остальные парсеры. Их определение такое же, как и раньше:

> using unary_exp3 = \
...> foldr_start_with_parser< \
...>   minus_token, \
...>   primary_exp3, \
...>   boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type \
...> >;
> using mult_exp6 = \
...> foldl_start_with_parser< \
...>   sequence<one_of<times_token, divides_token>, unary_exp3>, \
...>   unary_exp3, \
...>   boost::mpl::quote2<binary_op> \
...> >;
> struct plus_exp3 : \
...> foldl_start_with_parser< \
...>   sequence<one_of<plus_token, minus_token>, mult_exp6>, \
...>   mult_exp6, \
...>   boost::mpl::quote2<binary_op> \
...> > {};
> using exp_parser20 = build_parser<plus_exp3>;

копипастная версия

Мы можем попытаться дать нашему новому парсеру недействительный вход:

> exp_parser20::apply<BOOST_METAPARSE_STRING("hello")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 1, missing_primary_expression> ....
<< compilation error >>

Сообщение об ошибке теперь более специфично для языка калькулятора. Это касается только одного случая, когда сообщения об ошибках могут быть улучшены. Другие случаи (например, отсутствие закрывающих зон, отсутствие операторов и т.д.) могут быть рассмотрены аналогичным образом.

Недостающие парены закрытия являются распространенными ошибками. Давайте посмотрим, как наши парсеры сообщают о них:

> exp_parser20::apply<BOOST_METAPARSE_STRING("(1+2")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 5, unpaired<1, 1, literal_expected<')'>>> ....
<< compilation error >>

Парсер может обнаружить, что отсутствует парен, и отчет об ошибке указывает на открытый парен, который не закрыт. Это выглядит великолепно, но мы еще не закончили. Давайте попробуем немного более сложный вход:

> exp_parser20::apply<BOOST_METAPARSE_STRING("0+(1+2")>::type
mpl_::integral_c<int, 0>

Сейчас это становится странным. Мы анализируем<+ <mult_exp>>элементы, используя<foldl_start_with_parser>(см. определение<plus_exp3>).<foldl_start_with_parser>парсирует вход, насколько это возможно, и останавливается, когда он не может его разобрать. В приведенном выше вводе он анализирует<0>в качестве начального элемента, а затем пытается разобрать первый<+<mult_exp>>элемент. Но разбор<<mult_exp>>части терпит неудачу из-за отсутствующего закрывающего парена. Так<foldl_start_with_parser>останавливает и игнорирует эту неудачную часть входа.

Результатом вышесказанного является то, что мы анализируем только часть входа<0>, игнорируем «мусор» в конце и предполагаем, что значение выражения<0>. Это можно исправить, используя<entire_input>. Наш парсер отклонит ввод (из-за «мусора» в конце), но сообщение об ошибке не будет полезным. Поэтому мы используем другой подход.

Когда<foldl_start_with_parser>останавливается, мы должны проверить, есть ли там дополнительный сломанный<+ <mult_exp>>или нет. Когда это произойдет, мы должны сообщить, что не так с этим сломанным<+ <mult_exp>>(например, недостающий закрывающий парен). Metaparse предоставляет<fail_at_first_char_expected>для реализации таких валидаций.<fail_at_first_char_expected><<parser>>проверяет, как<parser>не может разобрать вход: когда он выходит из строя прямо при первом символе,<fail_at_first_char_expected>предполагает, что нет мусора и принимает вход. Когда<parser>потребляет символы из ввода до отказа,<fail_at_first_char_expected>предполагает, что существует нарушенное выражение и распространяет ошибку. Его можно использовать следующим образом:

> #include <boost/metaparse/fail_at_first_char_expected.hpp>
> #include <boost/metaparse/first_of.hpp>
> struct plus_exp4 : \
...> first_of< \
...>   foldl_start_with_parser< \
...>     sequence<one_of<plus_token, minus_token>, mult_exp6>, \
...>     mult_exp6, \
...>     boost::mpl::quote2<binary_op> \
...>   >, \
...>   fail_at_first_char_expected< \
...>     sequence<one_of<plus_token, minus_token>, mult_exp6> \
...>   > \
...> > {};
> using exp_parser21 = build_parser<plus_exp4>;

копипастная версия

<first_of>похож на<middle_of>, но сохраняет результат первого элемента, а не среднего. Мы используем его, чтобы сохранить «реальный» результат (результат<foldl_start_with_parser>) и отбросить фиктивный результат, идущий от<fail_at_first_char_expected>, когда в конце нет нарушенного выражения.<first_of>распространяет любую ошибку, исходящую от<fail_at_first_char_expected>.

Давайте попробуем это новое выражение парсер с отсутствующим закрывающим парен:

> exp_parser21::apply<BOOST_METAPARSE_STRING("0+(1+2")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 7, unpaired<1, 3, literal_expected<')'>>> ....
<< compilation error >>

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

> #include <boost/metaparse/foldl_reject_incomplete_start_with_parser.hpp>
> struct plus_exp5 : \
...> foldl_reject_incomplete_start_with_parser< \
...>   sequence<one_of<plus_token, minus_token>, mult_exp6>, \
...>   mult_exp6, \
...>   boost::mpl::quote2<binary_op> \
...> > {};
> using exp_parser22 = build_parser<plus_exp5>;

> exp_parser22::apply<BOOST_METAPARSE_STRING("0+(1+2")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 7, unpaired<1, 3, literal_expected<')'>>> ....
<< compilation error >>

11.3.2. Using foldl_reject_incomplete_start_with_parser at other places as well

Мы заменили один<foldl_start_with_parser>на<foldl_reject_incomplete_start_with_parser>. Другие слои (<mult_exp>,<unary_exp>и т. д.) также используют складывание. Давайте использовать его на всех уровнях:

> struct plus_exp6;
> using paren_exp5 = middle_of<lparen_token, plus_exp6, rparen_token>;
> using primary_exp4 = one_of<int_token, paren_exp5, fail<missing_primary_expression>>;
> using unary_exp4 = \
...> foldr_start_with_parser< \
...>   minus_token, \
...>   primary_exp4, \
...>   boost::mpl::lambda<boost::mpl::negate<boost::mpl::_1>>::type \
...> >;
> using mult_exp7 = \
...> foldl_reject_incomplete_start_with_parser< \
...>   sequence<one_of<times_token, divides_token>, unary_exp4>, \
...>   unary_exp4, \
...>   boost::mpl::quote2<binary_op> \
...> >;
> struct plus_exp6 : \
...> foldl_reject_incomplete_start_with_parser< \
...>   sequence<one_of<plus_token, minus_token>, mult_exp7>, \
...>   mult_exp7, \
...>   boost::mpl::quote2<binary_op> \
...> > {};
> using exp_parser23 = build_parser<plus_exp6>;

копипастная версия

	Note
	Обратите внимание, что<unary_exp4>использует<foldr_start_with_parser>вместо<foldr_reject_incomplete_start_with_parser>. Причина этого в том, что нет<foldr_reject_incomplete_start_with_parser>.<foldr_start_with_parser>применяет парсер<primary_exp4>, когда<minus_token>больше не принимает вход. Поэтому предполагается улавливать ошибки неполных выражений после повторения.

Давайте попробуем разные некорректные выражения:

> exp_parser23::apply<BOOST_METAPARSE_STRING("1+(2*")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 6, missing_primary_expression> ....
<< compilation error >>
> exp_parser23::apply<BOOST_METAPARSE_STRING("1+(2*3")>::type
<< compilation error >>
..... x__________________PARSING_FAILED__________________x<1, 7, unpaired<1, 3, literal_expected<')'>>> ....
<< compilation error >>