Need help understanding why actions don't [always] trigger

[0x8000-0000]

Considering this test case:

#include <tao/pegtl.hpp>
#include <tao/pegtl/ascii.hpp>
#include <tao/pegtl/rules.hpp>

#include <tao/pegtl/contrib/analyze.hpp>
#include <tao/pegtl/contrib/trace.hpp>

#include <cassert>
#include <charconv>
#include <iostream>

struct Specification
{
};

namespace
{
namespace pegtl = tao::pegtl;

struct Sep : pegtl::plus<pegtl::ascii::space>
{
};

struct Semi : pegtl::one<';'>
{
};

// Template to generate rule
// tao::pegtl::seq<Rule0, Separator, Rule1, Separator, Rule2, ... , Separator, RuleN>
template<typename Separator, typename... Rules>
struct Interleaved;

template<typename Separator, typename Rule0, typename... RulesRest>
struct Interleaved<Separator, Rule0, RulesRest...> : pegtl::seq<Rule0, Separator, Interleaved<Separator, RulesRest...>>
{
};

template<typename Separator, typename Rule0>
struct Interleaved<Separator, Rule0> : Rule0
{
};

// Note: interleaved<Separator /*, no Rule! */> intentionally not defined.

template<typename... Rules>
using SpacedSeq = Interleaved<Sep, Rules...>;

struct UnsignedInteger : pegtl::plus<pegtl::digit>
{
};

struct KeywordCount : pegtl::keyword<'c', 'o', 'u', 'n', 't'>
{
};

struct KeywordAmount : pegtl::keyword<'a', 'm', 'o', 'u', 'n', 't'>
{
};

struct Ingredient :
    SpacedSeq<pegtl::identifier,
              pegtl::sor<SpacedSeq<KeywordCount, UnsignedInteger>,
                         SpacedSeq<KeywordAmount, UnsignedInteger, pegtl::identifier>>>
{
};

template<typename Rule>
struct Statement : pegtl::seq<Rule, pegtl::star<pegtl::ascii::space>, Semi>
{
};

struct Recipe : pegtl::seq<pegtl::list<Statement<Ingredient>, Sep>, pegtl::eof>
{
};

template<typename Rule>
struct Action : pegtl::nothing<Rule>
{
};

template<>
struct Action<UnsignedInteger>
{
    template<typename Input>
    static void apply(const Input& in, Specification& /* specification */)
    {
        std::cout << "Raw matched integer: " << in.string_view() << '\n';

        int quantity = -1;

        [[maybe_unused]] const auto [ptr, ec] = std::from_chars(in.begin(), in.end(), quantity, 10);
        assert(ptr == in.end());

        std::cout << "Parsed integer: " << quantity << '\n';
    }
};

template<>
struct Action<pegtl::identifier>
{
    template<typename Input>
    static void apply(const Input& in, Specification& /* specification */)
    {
        std::cout << "Found identifier:" << in.string_view() << "\n";
    }
};

template<>
struct Action<Ingredient>
{
    template<typename Input>
    static void apply(const Input& in, Specification& /* specification */)
    {
        std::cout << "Found ingredient.\n";
    }
};

template<>
struct Action<Recipe>
{
    template<typename Input>
    static void apply(const Input& in, Specification& /* specification */)
    {
        std::cout << "Found recipe.\n";
    }
};

}  // namespace

static constexpr std::string_view input0 = R"txt(eggs count 2;)txt";

static constexpr std::string_view input1 = R"txt(eggs count 2;
flour amount 5 oz;)txt";

int main()
{
    const std::size_t issues = tao::pegtl::analyze<Recipe>();
    std::cout << "Analized the grammar and found " << issues << " issues.\n";

    Specification specification;

    {
        std::cout << "Tracing the grammar rules\n";
        pegtl::memory_input in(input1.data(), input1.size(), "");
        pegtl::standard_trace<Recipe>(in);
    }

    {
        std::cout << "Parsing in ?action\n";
        pegtl::memory_input in(input1.data(), input1.size(), "");
        pegtl::parse<Recipe, Action>(in, specification);
    }

    return 0;
}

When I run it, I get that the input is parsed correctly, but the output is this:

Parsing in ?action
Found identifier:eggs
Found ingredient.
Found identifier:flour
Raw matched integer: 5
Parsed integer: 5
Found ingredient.
Found recipe.

So I am missing the unsigned integer "2" on the first line, and the identifier "oz" on the second line.

I have tried creating the parse tree, and the nodes are missing as well.

What am I doing wrong? Thank you!

PS: I am using PEGTL 3.2.1, compiled with Clang13 on Linux, in both C++17 and C++20 modes.

[d-frey]

This is due to the Interleaved-helper not actually generating the type you think it does. You comment suggests it generates

pegtl::seq< rule0, sep, rule1, sep, rule2, sep, ... >

whereas in fact, it generates

pegtl::seq< rule0, sep, interleaved< rule1, rule2, ... > >

and now your specializations for the actions don't match anymore.

You need a different approach, something like:

   // Template to generate rule                                                                                                                     
   // tao::pegtl::seq<Rule0, Separator, Rule1, Separator, Rule2, ... , Separator, RuleN>                                                            
   template< typename Result, typename Separator, typename... Rules >
   struct InterleavedImpl;

   template< typename... Results, typename Separator, typename Rule0, typename... RulesRest >
   struct InterleavedImpl< pegtl::seq< Results... >, Separator, Rule0, RulesRest... >
      : InterleavedImpl< pegtl::seq< Results..., Rule0, Sep >, Separator, RulesRest... >
   {};

   template< typename... Results, typename Separator, typename Rule0 >
   struct InterleavedImpl< pegtl::seq< Results... >, Separator, Rule0 >
   {
      using type = pegtl::seq< Results..., Rule0 >;
   };

   template< typename Separator, typename... Rules >
   using Interleaved = typename InterleavedImpl< pegtl::seq<>, Separator, Rules... >::type;

[d-frey]

Hm, good start. But S is not necessarily a spacer, it's some separator. And the "tuple" is a sequence of rules. OTOH separated_seq is a bit long. Why is naming always the hardest part? 🤔

[0x8000-0000]

A "spacer" is not necessarily made out of invisible stuff. Also this...

[d-frey]

I get what you mean, but I think the physical world is different from CS. I don't think that anyone in our domain would call "comma" a spacer, it's a separator.

[0x8000-0000]

How about

sep< S, Q >

but requiring Q to a sequence?

seq< A, B, C, D >

Maybe using concepts?

So it could be written inline as:

sep< S, seq< A, B, C, D > >

[d-frey]

No, that breaks the uniformity of our interface. If seq< A, B, C, D > is visible in the user's grammar, it must be possible to apply actions to that exact rule.

[0x8000-0000]

Hi @d-frey - what is a timeline for the next [point] release? I'd like to make use of this new contrib class, but we're trying to stick to official releases. Is this worthy enough of a 3.2.2, and is HEAD stable enough?

Thank you,
florin

[d-frey]

We will do a final point release before migrating the license, but we need to clean up some details and adjust the documentation. Due to lack of time, it looks like we will need about 2-3 weeks.

[0x8000-0000]

Understood, thank you.