anchor.diff:  
   let identifier (identifierName : string) = SyntaxFactory.IdentifierName(identifierName)
   
  +/// onExpr.name
   let memberAccess (name : string) (onExpr : ExpressionSyntax) =
       SyntaxFactory.MemberAccessExpression(
           SyntaxKind.SimpleMemberAccessExpression,
  
positive.code:     /// Unary operator to convert C# Task<'t> to F# Async<'t>
      let (!!) t = Async.AwaitTask t
  
  type CompilationUnitSyntax with
      member this.AddUsings([<System.ParamArrayAttribute>] items : string array) =
          let directives =
              items
              |> Array.map (fun name -> SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(name)))
  
          this.AddUsings(directives)
  
  type TypeSyntax with
      static member Object = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.ObjectKeyword))
      static member String = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.StringKeyword))
      static member Int = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.IntKeyword))
      static member Bool = SyntaxFactory.PredefinedType(SyntaxFactory.Token(SyntaxKind.BoolKeyword))
  
  module Literal = 
      let Null = SyntaxFactory.LiteralExpression(SyntaxKind.NullLiteralExpression)
      let True = SyntaxFactory.LiteralExpression(SyntaxKind.TrueLiteralExpression)
      let False = SyntaxFactory.LiteralExpression(SyntaxKind.FalseLiteralExpression)
      let Bool (b:bool) = if b then True else False
  
      let String (s:string) =
          SyntaxFactory.LiteralExpression(SyntaxKind.StringLiteralExpression, SyntaxFactory.Literal(s))
  
      let Int (i:int) =
          SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(i))
  
  let inline addModifiers syntaxKinds (input:^T) =
      let tokens = syntaxKinds |> Array.map (fun k -> SyntaxFactory.Token(k))
  
negative.code:     let block = SyntaxFactory.Block(SyntaxFactory.List<StatementSyntax>(statements))
      (^T : (member WithBody : BlockSyntax -> ^T) (input, block))
  
  /// this.memberName = value;
  let setThisMember (memberName:string) value =
      SyntaxFactory.ExpressionStatement(
          SyntaxFactory.AssignmentExpression(
  