anchor.diff:  
   |====
   
  -==== Chaining with extra semantics
  +==== Chains 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]
  
positive.code: Chains of closed unary operators have an unambiguous operator tree.
  ====
  
  ==== Chaining binary operators
  Binary operators that allow chaining with themselves of other operators of compatible result type on the same precedence level are
  
  * https://raw.githack.com/openCypher/openCypher/master/tools/grammar-production-links/grammarLink.html?p=PowerOfExpression[Exponentiation]
  
negative.code: 
  == What others do
  
  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[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
  
  