Flattened operator node

[oovm]

My usage example can be simplified as follows:

I want to put operators of the same precedence level together, something like this:

a < 1 < b == 3
=> [a, (<, 1), (<, b), (==, 3)] // ok
=> [a, <, 1, <, b, ==, 3]  // also ok

My idea is to write such rules base (op expr)+, specifically as follows:

module.exports = grammar({
    name: 'calc',
    extras: $ => [
        /\s/,
    ],
    supertypes: $ => [],
    inline: $ => [
    ],
    word: $ => $.id,

    rules: {
        program: $ => repeat(seq($.expression, $._eos)),

        expression: $ => choice(
            seq("(", $.expression, ")"),
            $.id,
            $.num,
            $.arith_expr, // 20
            $.cmp_expr,   //10
        ),

        arith_expr: $ => prec.left(20,
            seq(
                field("base", $.expression),
                repeat1(seq(
                    field("op", $.arithmetic_op),
                    field("expr", $.expression),
                ))),
        ),
        arithmetic_op: $ => choice(
            "+", "-"
        ),

        cmp_expr: $ => prec.left(10,
            seq(
                field("base", $.expression),
                repeat1(seq(
                    field("op", $.compare_op),
                    field("expr", $.expression),
                ))),
        ),
        compare_op: $ => choice(
            ">=", ">", "<=", "<", "=="
        ),

        // Atomic
        id: $ => /[a-zA-Z]/,
        num: $ => token(/0|[1-9][0-9]*/),
        _eos: $ => ";",
    }
});

My expected result is:

(program
  (expression
    (cmp_expr
      (expression
        (id))
      (compare_op)
      (expression
        (num))
      (compare_op)
      (expression
        (id))
      (compare_op)
      (expression
        (num)))))

But the result is like this:

(program
  (expression
    (cmp_expr
      (expression
        (id))
      (compare_op)
      (expression
        (cmp_expr
          (expression
            (num))
          (compare_op)
          (expression
            (cmp_expr
              (expression
                (id))
              (compare_op)
              (expression
                (num)))))))))

This is too weird.

It is clearly left-associative, but it turns out to be right-associative, and it's not flattened.

How do I need to write rules to get the flattened node?

[ahelwer]

I have something similar in my language but ended up deciding it just wasn't needed to parse it in this flat way vs. a nested left-associative tree. What is your use case?

[oovm]

You are right, but I want to move as much work as possible to the parse stage

[ahlinc]

To flatten you need to use a combination of visible and hidden rules like on a bellow example that does what you need:

module.exports = grammar({
    name: 'calc',

    word: $ => $.id,

    rules: {
        program: $ => repeat(seq($.expression, $._eos)),

        expression: $ => choice(
            seq("(", $._expression, ")"),
            $.id,
            $.num,
            $.arith_expr,
            alias($._cmp_expr, $.cmp_expr),               // Unhide only top level $.cmp_expr
        ),

        _expression: $ => choice(                         // Hide recursive rule
            seq("(", $._expression, ")"),
            $.id,
            $.num,
            $.arith_expr,  // 20
            $._cmp_expr,   // 10
        ),

        arith_expr: $ => prec.left(20,
            seq(
                field("base", $._expression),
                repeat1(seq(
                    field("op", $.arithmetic_op),
                    field("expr", $._expression),
                ))),
        ),
        arithmetic_op: $ => choice(
            "+", "-"
        ),

        _cmp_expr: $ => prec.left(10,                    // Hide recursive rule
            seq(
                field("base", $._expression),
                repeat1(seq(
                    field("op", $.compare_op),
                    field("expr", $._expression),
                ))),
        ),
        compare_op: $ => choice(
            ">=", ">", "<=", "<", "=="
        ),

        // Atomic
        id: $ => /[a-zA-Z]+/,
        num: $ => token(/0|[1-9][0-9]*/),
        _eos: $ => ";",
    }
});

[bostick]

With the above grammar, the input (a < b < c) < d < e; parses as:

(program [0, 0] - [0, 20]
  (expression [0, 0] - [0, 19]
    (cmp_expr [0, 0] - [0, 19]
      base: (id [0, 1] - [0, 2])
      op: (compare_op [0, 3] - [0, 4])
      base: (id [0, 5] - [0, 6])
      op: (compare_op [0, 7] - [0, 8])
      expr: (id [0, 9] - [0, 10])
      op: (compare_op [0, 12] - [0, 13])
      base: (id [0, 14] - [0, 15])
      op: (compare_op [0, 16] - [0, 17])
      expr: (id [0, 18] - [0, 19]))))

e.g. the parens are lost.

It seems the answer grammar is "top-level only".

Is there a way to achieve "flattened operator" for anywhere inside of a grammar?