How to implement array support in the calculator example

[eakl]

I am building a calculator with Chevrotain parser and I have played with the calculator example

Chevrotain Playground: https://chevrotain.io/playground/
Parser Grammar: Calculator embedded semantics
Input Sample: Parenthesis precedence

The example above uses integer as input/output. I would like to support integers AND arrays.

Basic example:
2 * ( 3 + 7 )

Example with arrays:
2 * ( {{array1}} + {{array2}} )

const map = {
  array1: [1, 2, 3, 4, 5],
  array2: [10, 20, 30, 40, 50]
}

I know how to lex and parse {{array}} but I don't know how to visit them or loop over the arrays to achieve the following result

2 * ( 1 + 10 ) = 22
2 * ( 2 + 20 ) = 44
2 * ( 3 + 30 ) = 66
2 * ( 4 + 40 ) = 88
2 * ( 5 + 50 ) = 110

End result of the parsing of 2 * ( {{array1}} + {{array2}} )
should be [22, 44, 66, 88, 110]

Once the AST has been created (including the arrays on some leaf node), how can I reduce it to the end result which is an array.

One approach is to have some sort of state and run the visitor as many time as array.length. But it is unclear to me how it can be implemented with Chevretain

[eakl]

I tried to have something like

$.RULE("topLevelExpression", (i, n) => {
  let array = [ ]
  while (i < n) {
   $.SUBRULE($.additionExpression)
   i++
  }

  return array
})

It doesn't work because SUBRULE appears more than once. Also n is difficult to know before the expression is parsed and the array length is known.

[bd82]

Hello @ekal.

My opinion is that once that computation become less than trivial I would prefer to build an intermediate data structure during parsing and perform the computations afterwards instead of during the parsing.

The code snippet you included above seems to indicate you are mixing those up and using an embedded actions parser to attempt to compute the result "on the fly"

• https://chevrotain.io/docs/tutorial/step3_adding_actions_root.html#alternatives

I suggest you try build an in memory tree structure representing the calculation (left operand, right operand, operator)
and perform the final result output by traversing this data structure (e.g via recursion).

This should simplify your problem as in the first step you would only have to collect the operands and operators.
The second stage of computing the results would be completely unrelated to parsing and become a general data structures problem.