anchor.diff:      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"
  +    //let UnaryOpExpr(R: P<Range>): P<Expression> = pipe2 UnaryOpChar (ExpressionDecl R) (fun op rhs -> UnaryOpExpr(op, rhs)) <!> "UnaryOpExpr"
      
  -    // Binary arithmetic operators for given range
  +    // 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>()
  
positive.code:         opp.AddOperator(InfixOperator("*", spaces, 4, Associativity.Left, (fun lhs rhs -> AST.BinOpExpr("*", lhs, rhs))))
          opp.AddOperator(InfixOperator("/", spaces, 4, Associativity.Left, (fun lhs rhs -> AST.BinOpExpr("/", lhs, rhs))))
          opp.AddOperator(InfixOperator("^", spaces, 5, Associativity.Left, (fun lhs rhs -> AST.BinOpExpr("^", lhs, rhs))))
          opp
      
      let BinOpExpr(R: P<Range>): P<Expression> = (BinOpForRangeParser R).ExpressionParser <!> "BinaryOpExpr"
  
      // Parsing Excel argument lists is ambiguous without knowing
      // the arity of the function that you are parsing.  Thus parsers in this grammar
  
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> =
  