anchor.diff:      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"
  +    //let UnaryOpChar = (spaces >>. satisfy (fun c -> c = '+' || c = '-') .>> spaces) <!> "UnaryOp"
   
       // reserved words
       let ReservedWordsReference: P<Reference> =
  
positive.code:     // 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))
              )
              <!> "Expression"
  
      // Formulas
  
negative.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"
     
      // Unary and Binary arithmetic operator parser generator for a given range parser
      // This exists because the OperatorPrecedenceParser does not take an opaque Term type
      let BinOpForRangeParser(R: P<Range>) =
          let opp = new OperatorPrecedenceParser<Expression,unit,Env>()
  