Constructor operators allow a constructor to use a variable reference as a label, extract the successors of a variable reference, or extract the label of a variable reference.

Consider generalizing the previous example to support multiple operators. This could be done by adding a new production for each operator -, *, /, ^. Alternatively a single rule can be established to match these operators and the output of that rule can be used as a label using id:

module Expression {
    language Expression {
        token Digits = ("0".."9")+;
        syntax Main
          = e:E => e;
        syntax Op
          = "+" => "Add"
          | "-" => "Subtract"
          | "*" => "Multiply"
          | "/" => "Divide" ;
        syntax E
          = d:Digits => d
          | l:E o:Op r:E => id(o){Left[l],Right[r]} ;
    }
}

Processing the text "1+2" with this language yields the same result as above. Processing "1 / 2" yields:

Divide{Left{1}, Right{2}}

This language illustrates the id operator. See Section 10.4.2 for a more realistic expression grammar.

The valuesof operator extracts the successors of a variable reference. It is used to flatten nested output structures. Consider the language:

module Digits {
    language Digits {
        syntax Main = DigitList ;
        token Digit = "0".."9";
        syntax DigitList
          = Digit
          | DigitList "," Digit ;
    }
}

Processing the text "1, 2, 3" with this language yields:

Main[
  DigitList[
    DigitList[
      DigitList[
        1
      ],
      ,,
      2
    ],
    ,,
    3
  ]
]

The following grammar uses valuesof and the pass through pattern above to simplify the output:

module Digits {
    language Digits {
        syntax Main = dl:DigitList => dl ;
        token Digit = "0".."9";
        syntax DigitList
          = d:Digit => DigitList[d]
          | dl:DigitList "," d:Digit => DigitList[valuesof(dl),d] ;
    }
}

Processing the text "1, 2, 3" with this language yields:

DigitList[1, 2, 3]

This output represents the same information more concisely.

If a constructor is not defined for a production, the language process defines a default constructor. For a given production, the default projection is formed as follows:

Consider the following language:

module ThreeDigits {
    language ThreeDigits {
        token Digit = "0".."9";
        syntax Main
          = Digit Digit Digit ;
    }
}

Given the text "123" the default output of the language processor follows:

Main[
  1,
  2,
  3
]

Consider the classic dangling else problem as represented in the following language:

module IfThenElse {
    language IfThenElse {
        syntax Main = S;
        syntax S
          = empty
          | "if" E "then" S
          | "if" E "then" S "else" S;
        syntax E = empty;
        interleave Whitespace = " ";
    }
}

Given the input “if then if then else”, two different output are possible. Either the else binds to the first if-then:

if
then
    if
    then
else

Or it binds to the second if-then:

if
then
    if
    then
    else

The following language produces the output immediately above, binding the else to the second if-then.

module IfThenElse {
    language IfThenElse {
        syntax Main = S;
        syntax S
          = empty
          | precedence 2: "if" E "then" S
          | precedence 1: "if" E "then" S "else" S;
        syntax E = empty;
        interleave Whitespace = " ";
    }
}

Switching the precedence values produces the first output.

Consider a simple expression language which recognizes:

2 + 3 + 4
5 * 6 * 7
2 + 3 * 4
2 ^ 3 ^ 4

The result of these expressions can depend on the order in which the operators are reduced. 2 + 3 + 4 yields 9 whether 2 + 3 is evaluated first or 3 + 4 is evaluated first. Likewise, 5 * 6 * 7 yields 210 regardless of the order of evaluation.

However, this is not the case for 2 + 3 * 4. If 2 + 3 is evaluated first yielding 5, then 5 * 4 yields 20. While if 3 * 4 is evaluated first yielding 12, then 2 + 12 yields 14. This difference manifests itself in the output of the following grammar:

module Expression {
    language Expression {
        token Digits = ("0".."9")+;
        syntax Main = e:E => e;
        syntax E
          = d:Digits => d
          | "(" e:E ")" => e
          | l:E "^" r:E => Exp[l,r]
          | l:E "*" r:E => Mult[l,r]
          | l:E "+" r:E => Add[l,r];
        interleave Whitespace = " ";
    }
}

" 2 + 3 * 4" can result in two outputs:

Mult[Add[2, 3], 4]
Add[2, Mult[3, 4]]

According to the rules we all learned in school, the result of this expression is 14 because multiplication is performed before addition. This is expressed in M_g by assigning "*" a higher precedence than "+". In this case the result of an expression changed with the order of evaluation of different operators.

The order of evaluation of a single operator can matter as well. Consider 2 ^ 3 ^ 4. This could result in either 8 ^ 4 or 2 ^ 81. In term of output, there are two possibilities:

Exp[Exp[2, 3], 4]
Exp[2, Exp[3, 4]]

In this case the issue is not which of several different operators to evaluate first but which in a sequence of operators to evaluate first, the leftmost or the rightmost. The rule in this case is less well established but most languages choose to evaluate the rightmost "^" first yielding 2 ^ 81 in this example.

The following grammar implements these rules using term precedence qualifiers. Term precedence qualifiers may only be applied to literals or references to token rules.

module Expression {
    language Expression {
        token Digits = ("0".."9")+;
        syntax Main = E;
        syntax E
          = d:Digits => d
          | "(" e:E ")" => e
          | l:E right(3) "^" r:E => Exp[l,r]
          | l:E left(2) "*" r:E => Mult[l,r]
          | l:E left(1) "+" r:E => Add[l,r];
        interleave Whitespace = " ";
    }
}

"^" is qualified with right(3). right indicates that the rightmost in a sequence should be grouped together first. 3 is the highest precedence, so "^" will be grouped most strongly.