anchor.diff:  
   == What others do
   
  -openCypher has grammatically all operator in one precedence level hierarchy.
  +openCypher has grammatically all operators in one precedence level hierarchy.
   This is similar to how precedence is defined for more programming languages.
   For instance:
   
   * https://docs.oracle.com/javase/tutorial/java/nutsandbolts/operators.html[Java]
   * https://docs.python.org/3/reference/expressions.html#operator-precedence[Python]
   * https://en.cppreference.com/w/cpp/language/operator_precedence[C++]
  -* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#table[Java Script]
  -
  +* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#table[Javascript]
  +
  +The precedence is similar.
  +Some minor difference:
  +
  +* Programming languages have extra operators openCypher does not have, e.g. increment/decrement, bitwise operators, ternary operator, and assignments
  +* In Javascript exponentiation is right-to-left associative
  +
  +SQL encodes large parts of the type compatibility of expressions in the grammar.
  +Hence, its precedence hierarchy is partition by type.
  +Within one type, SQL's precedence hierarchy is similar.
  +
  +Chainable operators, such as addition, multiplication, etc. are left-to-right associative in SQL as well.
  +However, SQL directly encode that in the grammar, with left-recursive production rules, e.g.
  +
  +[source, ebnf]
  +----
  +<numeric value expression> ::=
  +    <term>
  +  | <numeric value expression> <plus sign> <term>
  +  | <numeric value expression> <minus sign> <term>
  +
  +<term> ::=
  +    <factor>
  +  | <term> <asterisk> <factor>
  +  | <term> <solidus> <factor>
  +
  +<factor> ::=
  +  [ <sign> ] <numeric primary>
  +----
  +
  +Most program and query language do not give chains of comparison operators extra semantics.
  +Typically, comparison operators are left-to-right associative.
   
   == Benefits to this proposal
   
  
positive.code: 
  |====
  
  ==== Chaining with extra semantics
  Operators whose chaining gives extra semantics are
  
  * https://raw.githack.com/openCypher/openCypher/master/tools/grammar-production-links/grammarLink.html?p=ComparisonExpression[Comparison operations]
  
negative.code: ----
  where the arithmetic addition is an operand to the arithmetic multiplication and, hence, results in `20` (rather than `11`).
  
  === Operator associativity
  
  Most precedence level include multiple operators.
  
  