anchor.diff:      /// 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))
  +    static member FromType (t:System.Type) = SyntaxFactory.ParseTypeName(t.FullName)
   
   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 EmptyString = String ""
   
       let Int (i:int) =
           SyntaxFactory.LiteralExpression(SyntaxKind.NumericLiteralExpression, SyntaxFactory.Literal(i))
  +    let Zero = Int 0
  +
  +let addUsings (usings : string array) (compilationUnit : CompilationUnitSyntax) =
  +    let directives = usings |> Array.map (fun name ->
  +        SyntaxFactory.UsingDirective(SyntaxFactory.IdentifierName(name)))
  +
  +    compilationUnit.AddUsings(directives)
   
   let inline addModifiers syntaxKinds (input:^T) =
       let tokens = syntaxKinds |> Array.map (fun k -> SyntaxFactory.Token(k))
  
positive.code: 
  let identifier (identifierName : string) = SyntaxFactory.IdentifierName(identifierName)
  
  let memberAccess (name : string) (onExpr : ExpressionSyntax) =
      SyntaxFactory.MemberAccessExpression(
          SyntaxKind.SimpleMemberAccessExpression,
  
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(
  