Backtracking from dsl::brackets

[DNKpp]

Hello,
I'm working on a parser, which accepts C++ type-names. Therefore, I'm currently working my way through the relevant productions given by the C++ standard. As those are more complex than necessary for my usecase, they still provide a good starting point for making that work and simplify them later.
At least that's my strategy for now, so I would like to transport them as closely to lexy as possible.

That out of the way, let me quickly demonstrate my issue.
Consider the two input strings char(*)[42] and char*() where the prior denotes "a pointer to an array of chars" and the latter "a function returning a pointer to char".
In fact, this case merely boils down to the decision between:

• noptr_abstract_declarator -> ( ptr_abstract_declarator ) and
• noptr_abstract_declarator -> parameters_and_qualifiers
  with:
• parameters_and_qualifiers -> ( parameter_declaration_clause ) (This is very much simplified!)
• parameter_declaration_clause -> parameter_declaration_list?

Note: ? means optional here.

As you can see, both productions share the ( as prefix. In the current setup I can successfully recognize char(*)[42] but fail with
char*(). However, when I change my decision from
dsl::parenthesized(dsl::recurse_branch<ptr_abstract_declarator>) | dsl::recurse_branch<parameters_and_qualifiers> (1) to dsl::recurse_branch<parameters_and_qualifiers> | dsl::parenthesized(dsl::recurse_branch<ptr_abstract_declarator>) (2) the outcomes will be negated.

Note: Actually the subscript branch is also part of that choice, but I omitted it here for brevity.

This the relevant part of tracing the char*() string with the setup (1):

// `char` is already consumed here
 1:  5: ├──lexy_test::grammar::abstract_declarator:
 1:  5: │  ├──lexy_test::grammar::ptr_abstract_declarator:
 1:  5: │  │  ├──lexy_test::grammar::ptr_operator:
 1:  5: │  │  │  ├──literal: *
 1:  6: │  │  │  ├──lexy_test::grammar::cv_qualifier_seq:
 1:  6: │  │  │  │  ┴
 1:  6: │  │  │  ┴
 1:  6: │  │  ├──lexy_test::grammar::ptr_operator:
 1:  6: │  │  │  ├──lexy_test::grammar::ref_qualifier:
 1:  6: │  │  │  │  └╳
 1:  6: │  │  │  └╳
 1:  6: │  │  ├──lexy_test::grammar::noptr_abstract_declarator:
 1:  6: │  │  │  ├──literal: (
 1:  7: │  │  │  ├──lexy_test::grammar::ptr_abstract_declarator:
 1:  7: │  │  │  │  ├──lexy_test::grammar::ptr_operator:
 1:  7: │  │  │  │  │  ├──lexy_test::grammar::ref_qualifier:
 1:  7: │  │  │  │  │  │  └╳
 1:  7: │  │  │  │  │  └╳
 1:  7: │  │  │  │  ├──lexy_test::grammar::noptr_abstract_declarator:
 1:  7: │  │  │  │  │  ├──lexy_test::grammar::parameters_and_qualifiers:
 1:  7: │  │  │  │  │  │  └╳
 1:  7: │  │  │  │  │  └╳
 1:  7: │  │  │  │  ├──error: exhausted choice
 1:  7: │  │  │  │  └╳
 1:  7: │  │  │  └╳
 1:  7: │  │  └╳
 1:  7: │  └╳
 1:  7: └╳

This correctly consumes the * and then consumes the ( (due to branch (1)) and eventually runs into a dead-end.
This is more or less the expected behaviour, but I expected it to just backtrack right before the ( literal and test branch (2).
So, my question is: Is it possible to somehow "unconsume" the ( when the branch (1) fails and let lexy try for branch (2)?

[foonathan]

That is not really possible. Instead, I'd recommend using the operator parser to parse expressions. See here for an example of how that looks: https://github.com/foonathan/clauf/blob/main/src/compiler.cpp#L1847-L1867