anchor.diff:  
   // Unary Operations
   type UnaryExpression =
  -    {
  -        Prefix: bool
  -        Argument: Expression
  -        Operator: string
  -        Loc: SourceLocation option
  -    }
  +    { Prefix: bool
  +      Argument: Expression
  +      Operator: string
  +      Loc: SourceLocation option }
  +
       static member AsExpr(operator_, argument, ?loc) : Expression =
           let prefix = true
           let operator =
  
positive.code: 
  // Should derive from Node, but make it an expression for simplicity
  type SpreadElement =
      {
          Argument: Expression
          Loc: SourceLocation option
      }
      static member AsExpr(argument, ?loc) : Expression =
          {
              Argument = argument
              Loc = loc
          } |> SpreadElement
      interface IPrintable with
          member this.Print(printer) =
              printer.Print("...", ?loc=this.Loc)
              printer.ComplexExpressionWithParens(this.Argument)
  
  type ArrayExpression =
      {
          // Elements: Choice<Expression, SpreadElement> option array
          Elements: Expression array
          Loc: SourceLocation option
      }
      static member AsExpr(elements, ?loc) : Expression =
          {
              // Elements: Choice<Expression, SpreadElement> option array
              Elements = elements
              Loc = loc
          } |> ArrayExpression
      interface IPrintable with
          member this.Print(printer) =
              printer.Print("[", ?loc=this.Loc)
              printer.PrintCommaSeparatedArray(this.Elements)
              printer.Print("]")
  
  
negative.code:             | BinaryAndBitwise -> "&"
              | BinaryIn -> "in"
              | BinaryInstanceOf -> "instanceof"
  
          { Left = left
            Right = right
            Operator = operator
            Loc = loc }
          |> BinaryExpression
      interface IPrintable with
          member this.Print(printer) =
              printer.PrintOperation(this.Left, this.Operator, this.Right, this.Loc)
  
  type AssignmentExpression =
      { Left: Expression
        Right: Expression
        Operator: string
        Loc: SourceLocation option }
  
      static member AsExpr(operator_, left, right, ?loc): Expression =
          let operator =
              match operator_ with
              | AssignEqual -> "="
  