anchor.diff:  
   let inline addBodyStatement statement (input:^T) =
       (^T : (member AddBodyStatements : StatementSyntax array -> ^T) (input, [|statement|]))
  -    
  +   
   let inline addMember member' (input:^T) =
       (^T : (member AddMembers : MemberDeclarationSyntax array -> ^T) (input, [|member'|]))
   
  
positive.code: 
  let identifier (identifierName : string) = SyntaxFactory.IdentifierName(identifierName)
  
  let memberAccess (name : string) (onExpr : ExpressionSyntax) =
      SyntaxFactory.MemberAccessExpression(
          SyntaxKind.SimpleMemberAccessExpression,
  
negative.code:     SyntaxFactory.InvocationExpression(expression)
          .WithArgumentList(argList)
  
  /// return expression;
  let ret expression = SyntaxFactory.ReturnStatement(expression)
  
  /// (expression)
  let parenthesis expression = SyntaxFactory.ParenthesizedExpression(expression)
  
  /// ((toType) expression)
  let cast toType expression = parenthesis (SyntaxFactory.CastExpression(toType, expression))
  
  /// (expression is checkedType)
  let is checkedType expression = parenthesis(SyntaxFactory.BinaryExpression(SyntaxKind.IsExpression, expression, checkedType))
  
  /// (left == right)
  let equals left right = parenthesis (SyntaxFactory.BinaryExpression(SyntaxKind.EqualsExpression, left, right))
  
  /// !(expression)
  let not' expression = SyntaxFactory.PrefixUnaryExpression(SyntaxKind.LogicalNotExpression, parenthesis expression)
  
  /// if (condition) then then'
  let if' condition then' = SyntaxFactory.IfStatement(condition, then')
  
  /// if (condition) then then' else else'
  let ifelse condition then' else' = SyntaxFactory.IfStatement(condition, then', SyntaxFactory.ElseClause(else'))
  
  /// {}
  let emptyBlock = SyntaxFactory.Block()
  
  /// { statements }
  let block (statements : StatementSyntax array) = SyntaxFactory.Block(statements)
  
  /// throw expression;
  let throw expression = SyntaxFactory.ThrowStatement(expression)
  
  /// typeof('t)
  let typenameof<'t> = TypeSyntax.FromType(typedefof<'t>)
  
  /// An empty file ("compilation unit")
  let emptyFile = SyntaxFactory.CompilationUnit()