How to do "cut"?

[viridia]

I'm trying to figure out how to make the parser report errors where they happen, as opposed to failing the enclosing rule. Other parser generators have a feature called "CUT" which means "don't try any more alternatives once you reach this point".

Here's an example: I'm trying to parse a structure like this:

main: template() {
  some: 1,
  random: 2,
  properties: $$XXXERROR
}

The error result I get back says that the problem is on line 1 - because the 'template' rule failed to parse. But what we'd really like to show the user is that the problem is on line 4.

If I could put a CUT at the end of each property, the parser would know that everything up to that point is OK, and it's only when we get to the bad property that things go off the rails.

[Tartasprint]

If I understand well you want the "why" the template rule failed ?
I don't know of any standard way to do this in Pest, but could you show the grammar you are writing, to help understanding your problem ?

[viridia]

Hmmm, my grammar has changed a lot since I wrote this but I'll try and come up with a simple example:

stmt = { if | assign }
if = { "if" ~ expr ~ block ~ "else" ~ block }
assign = { identifier ~ "=" ~ expr }

Now, suppose the input text is something like "if )". The parser will first attempt to parse the "if" rule, and when that fails, it will go on to parse the "assign" rule, treating the word "if" as an identifier.

However, once we see the word "if" we know in this case that the input is an if-statement and not an assignment. So if we could put a CUT in the grammar like this:

if = { "if" <<CUT>> ~ expr ~ block ~ "else" ~ block }

The "CUT" means that once we reach this point, we're committed to this rule, no other alternative rules will be tried. The rule will either succeed, or an error will be generated, and the error will show that we expected to see an expression following the "if".

[Tartasprint]

You could write something like:

stmt = { if | !("if") ~ assign }
if = { "if" ~ expr ~ block ~ "else" ~ block }
assign = { identifier ~ "=" ~ expr }

Otherwise you could have the rule for identifiers exclude the keywords:

free_identifier = @{XID_START ~ XID_CONTINUE*}
keyword = {"if" | "else"}
identifier = { ! keyword ~ free_identifier}

I wrote a small grammar filling the missing rules of your example to show it in action on the playground.

To do a CUT like this:

r={ prefix ~ <<CUT>> ~ tail | alt1 | alt2 | ... }

You can do:

r={ prefix ~ tail | !prefix ~ (alt1 | alt2 | ... ) }

You might need to tweak this a little bit if you don't want WHITESPACE before alt1 | alt2 | ... because of the predicate !prefix~.

[viridia]

Yes, you can re-write the grammar to exclude the other alternatives - but this gets more difficult as the number of alternatives increases. The example I gave was deliberately simplified, in an actual real-world use case it would not be as easy to re-write the grammar.

The "cut err" feature, on the other hand, is fairly simple (from the perspective of a person writing a grammar - it might not be simple to implement).

This is something that winnow has: https://docs.rs/winnow/latest/winnow/combinator/fn.cut_err.html

BTW, the term "cut" apparently comes from prolog. I'm not sure that it's a standard term for parsers, although I have found a couple of discussions on the web that use that word, for example https://news.ycombinator.com/item?id=20502032

In any case, I can work around the absence of this feature.

[Tartasprint]

You are probably right, this CUT feature seams very nice to me !

[Tartasprint]

And I just saw the feature you request is proposed for pest3. They call it a trap, but from the description it's the same. You could upvote the proposition, if you are intrested :)