[#foldr_reject_incomplete]
[section foldr_reject_incomplete]

[h1 Synopsis]

  template <class P, class State, class BackwardOp>
  struct foldr_reject_incomplete;

This is a [link parser_combinator parser combinator].

[table Arguments
  [[Name]         [Type]]
  [[`P`]          [[link parser parser]]]
  [[`State`]      [[link metaprogramming_value template metaprogramming value]]]
  [[`BackwardOp`] [[link metafunction_class template metafunction class] taking two arguments]]
]

[h1 Description]

The same as [link foldr `foldr`], but once `P` rejects the input,
`foldr_reject_incomplete` checks if `P` consumes any characters before rejecting
the input. If so, `foldr_reject_incomplete` rejects the input with the same
error message this last application of `P` returned. Otherwise
`foldr_reject_incomplete` accepts the input and gives the same result as
[link foldr `foldr`].

Here is a diagram showing how `foldr_reject_incomplete` works by example:

  using int_token = token<int_>;
  using plus_token = token<lit_c<'+'>>;
  using plus_int = last_of<plus_token, int_token>;
  using sum_op = mpl::lambda<mpl::plus<mpl::_1, mpl::_2>>::type;

[$images/metaparse/foldr_reject_incomplete_diag1.png [width 70%]]

Note that `foldr_reject_incomplete` folds from right to left and therefore does
not start folding until it reaches the end of the sequence. Since at the end of
the sequence it finds an error, folding does not happen at all.

[h1 Header]

  #include <boost/metaparse/foldr_reject_incomplete.hpp>

[h1 Expression semantics]

For any `p` parser, `t` class, `f` metafunction class taking two arguments,
`s` compile-time string and `pos` source position

  foldr_reject_incomplete<p, t, f>::apply<s, pos>

is equivalent to

  first_of<foldr<p, t, f>, fail_at_first_char_expected<p> >::apply<s, pos>

[h1 Example]

  #include <boost/metaparse/foldr_reject_incomplete.hpp>
  #include <boost/metaparse/lit_c.hpp>
  #include <boost/metaparse/last_of.hpp>
  #include <boost/metaparse/token.hpp>
  #include <boost/metaparse/int_.hpp>
  #include <boost/metaparse/string.hpp>
  #include <boost/metaparse/start.hpp>
  #include <boost/metaparse/get_result.hpp>
  #include <boost/metaparse/is_error.hpp>
  
  #include <boost/mpl/lambda.hpp>
  #include <boost/mpl/plus.hpp>
  #include <boost/mpl/int.hpp>
  
  using namespace boost::metaparse;
  
  using int_token = token<int_>;
  using plus_token = token<lit_c<'+'>>;
  using plus_int = last_of<plus_token, int_token>;
  using sum_op =
    boost::mpl::lambda<boost::mpl::plus<boost::mpl::_1, boost::mpl::_2>>::type;
  
  using ints = foldr_reject_incomplete<plus_int, boost::mpl::int_<11>, sum_op>;
  
  static_assert(
    get_result<
      ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 + 21"), start>
    >::type::value == 48,
    "ints should sum the numbers"
  );
  
  static_assert(
    is_error<
      ints::apply<BOOST_METAPARSE_STRING("+ 13 + 3 +"), start>
    >::type::value,
    "when the last number is missing, it should be an error"
  );

[endsect]