Feature Request: Flattening single-child branches operator

[adzierzanowski]

I very much like Owl but there's a single feature I miss. In Lark python parsing library there's a neat ? operator which replaces a node in resulting tree with its child if there's only one.

So for example a parser with the following grammar (using ? as in Lark)

program = stmt*
stmt =
   'print' expr : print
?expr =
   [ '(' expr ')' ] : parens
   identifier : variable
   number : literal
 .operators prefix
   '-' : negative
 .operators infix left
   '+' : plus
   '-' : minus

would produce

program (0 - 7)
  stmt : PRINT (0 - 7)
    number - 1.000000 (6 - 7)

instead of

program (0 - 7)
  stmt : PRINT (0 - 7)
    expr : LITERAL (6 - 7)
      number - 1.000000 (6 - 7)

Is such feature possible in the future or is it out of scope of the project?

[ianh]

Hi, thanks for the suggestion! I wouldn't say this is out-of-scope, but my focus is currently on other things, and I think this would be a tricky change to make (Owl uses an immutable packed representation in memory for the parse tree; it does keep everything small and contiguous, but it also makes changing anything a pain). Amusingly, adding the ? syntax as-given produces an ambiguity in Owl's grammar:

error: this grammar is ambiguous

. a = "a" ? b = "b" 

  can be parsed in two different ways: as

. a = "a"          ? b = "b"          
  |   expr:literal   |   |            
  |   expr:optional- |   expr:literal 
  |   body---------- |   body-------- 
  rule:normal------- rule:normal----- 
  grammar---------------------------- 

  or as

. a = "a"          ? b = "b"          
  |   expr:literal |     expr:literal 
  |   body-------- |     body-------- 
  rule:normal----- rule:flatten------ 
  grammar---------------------------- 

…so a different syntax would have to be chosen as well.