anchor.diff:          (       
               (   // fixed arity
                   arityNNameArr |>
  -                    Array.mapi (fun i _ -> (attempt (ArityNFunction i R))) |> choice)
  -            <|> (// low-bounded arity
  +                    Array.mapi (fun i _ -> (attempt_opt (ArityNFunction i R))) |> choice_opt)
  +            <||> (// low-bounded arity
                   arityAtLeastNNameArr |>
                       // note: no "at-least-0" parser; that's just a varargs
  -                    Array.mapi (fun i _ -> (attempt (ArityAtLeastNFunction (i + 1) R))) |> choice)
  -            <|> (// varargs
  +                    Array.mapi (fun i _ -> (attempt_opt (ArityAtLeastNFunction (i + 1) R))) |> choice_opt)
  +            <||> (// varargs
                   VarArgsFunction R)
           ) <!> "Function"
       
  
positive.code: 
      // Binary arithmetic operators
      let BinOpChar = spaces >>. satisfy (fun c -> c = '+' || c = '-' || c = '/' || c = '*' || c = '<' || c = '>' || c = '=' || c = '^' || c = '&') .>> spaces
      let BinOp2Char = spaces >>. ((attempt (regex "<=")) <|> (attempt (regex ">=")) <|> regex "<>") .>> spaces
      let BinOpLong R: P<string*Expression> = pipe2 BinOp2Char (ExpressionDecl R) (fun op rhs -> (op, rhs))
      let BinOpShort R: P<string*Expression> = pipe2 BinOpChar (ExpressionDecl R) (fun op rhs -> (op.ToString(), rhs))
      let BinOp R: P<string*Expression> = ((attempt (BinOpLong R)) <|> (BinOpShort R)) <!> "BinaryOp"
  
      // Unary operators
      let UnaryOpChar = (spaces >>. satisfy (fun c -> c = '+' || c = '-') .>> spaces) <!> "UnaryOp"
  
      // reserved words
      let ReservedWordsReference: P<Reference> =
          (Array.map (fun (rwp: P<string>) -> (attempt rwp)) ReservedWords)
          |> choice
          |>> (fun s ->
                  raise (AST.ParseException ("'" + s + "' is a reserved word."))
              )
  
      // references
      let Reference R = (attempt (RangeReference R))
                          <|> (attempt AddressReference)
                          <|> (attempt BooleanReference)
                          <|> (attempt ConstantReference)
                          <|> (attempt ReservedWordsReference)
                          <|> (attempt StringReference)
                          <|> NamedReference
                        <!> "Reference"
  
      // Expressions
      let ParensExpr(R: P<Range>): P<Expression> = ((between (pstring "(") (pstring ")") (ExpressionDecl R)) |>> ParensExpr) <!> "ParensExpr"
      let ExpressionAtom(R: P<Range>): P<Expression> = (((attempt (Function R)) <|> (Reference R)) |>> ReferenceExpr) <!> "ExpressionAtom"
      let ExpressionSimple(R: P<Range>): P<Expression> = ((attempt (ExpressionAtom R)) <|> (ParensExpr R)) <!> "ExpressionSimple"
      let UnaryOpExpr(R: P<Range>): P<Expression> = pipe2 UnaryOpChar (ExpressionDecl R) (fun op rhs -> UnaryOpExpr(op, rhs)) <!> "UnaryOpExpr"
      let BinOpExpr(R: P<Range>): P<Expression> = pipe2 (ExpressionSimple R) (BinOp R) (fun lhs (op, rhs) -> BinOpExpr(op, lhs, rhs)) <!> "BinaryOpExpr"
     
  
negative.code:                             |>> (fun expr -> IndirectAddress(expr, us) :> Address)
      let AddrR1C1 = getUserState >>=
                      fun (us: Env) ->
                          (attempt_opt AddrIndirect)
                          <||> (pipe2
                                  AddrR
                                  AddrC
                                  (fun row col ->
                                      // TODO: R1C1 absolute/relative
                                      Address.fromR1C1withMode(row, col, AddressMode.Relative, AddressMode.Relative, us.WorksheetName, us.WorkbookName, us.Path)))
                      <!> "AddrR1C1"
      let AbsOrNot : P<AddressMode> = (attempt_opt ((pstring "$") >>% Absolute) <||> (pstring "" >>% Relative)) 
      let AddrA = many1Satisfy isAsciiUpper
      let AddrAAbs = pipe2 AbsOrNot AddrA (fun mode col -> (mode, col))
      let Addr1 = pint32
      let Addr1Abs = pipe2 AbsOrNot Addr1 (fun mode row -> (mode, row))
      let AddrA1 = getUserState >>=
                      fun (us: Env) ->
                          (attempt_opt AddrIndirect)
                          <||> (pipe2
                              AddrAAbs
                              Addr1Abs
                              (fun col row ->
  