anchor.diff:      // By default, the grammar tries to parse both (see top-level Formula parser).
       do ExpressionDeclImpl :=
           fun (R: P<Range>) ->
  -            (
  -                ((attempt_opt (UnaryOpExpr R))
  -                <||> (attempt_opt (BinOpExpr R))
  -                <||> (ExpressionSimple R))
  -            )
  +            (attempt_opt (OpExpr R))
  +            <||> (ExpressionSimple R)
               <!> "Expression"
   
       // Formulas
  
positive.code:     let ParensExpr(R: P<Range>): P<Expression> = ((between (pstring "(") (pstring ")") (ExpressionDecl R)) |>> ParensExpr) <!> "ParensExpr"
      let ExpressionAtom(R: P<Range>): P<Expression> = (((attempt_opt (Function R)) <||> (Reference R)) |>> ReferenceExpr) <!> "ExpressionAtom"
      let ExpressionSimple(R: P<Range>): P<Expression> = ((attempt_opt (ExpressionAtom R)) <||> (ParensExpr R)) <!> "ExpressionSimple"
      let UnaryOpExpr(R: P<Range>): P<Expression> = pipe2 UnaryOpChar (ExpressionDecl R) (fun op rhs -> UnaryOpExpr(op, rhs)) <!> "UnaryOpExpr"
     
      // Binary arithmetic operators for given range
      // This exists because the OperatorPrecedenceParser does not take an opaque Term type
      let BinOpForRangeParser(R: P<Range>) =
          let opp = new OperatorPrecedenceParser<Expression,unit,Env>()
  
negative.code:     do ArgumentListImpl := fun (R: P<Range>) -> sepBy ((ExpressionDecl R) <!> "VarArgs Argument") Comma <!> "ArgumentList"
  
      // Unary operators
      //let UnaryOpChar = (spaces >>. satisfy (fun c -> c = '+' || c = '-') .>> spaces) <!> "UnaryOp"
  
      // reserved words
      let ReservedWordsReference: P<Reference> =
  