anchor.diff:    open System.Linq.Expressions
   
     //Type Aliases
  -  type private Et = Expression
  -  type private EtParam = ParameterExpression
  -
     type Expr = Expression
  -  type ExprParam = ParameterExpression
     type Parameter = ParameterExpression
     type Lambda = LambdaExpression
  -
     type Label = LabelTarget
     type ExprType = ExpressionType
     type Br = BindingRestrictions
  
positive.code:     let local name type' = Expr.Variable(type', name)
      let localT<'a> name = var name typeof<'a>
      
      let param name type' = Et.Parameter(type', name)
      let paramT<'a> name = param name typeof<'a>
  
      let paramRef name (type':Type) = param name (type'.MakeByRefType())
  
negative.code:   type IMetaObjProvider = IDynamicMetaObjectProvider
  
    //Defaults
    let void' = Expr.Default(typeof<System.Void>) :> Expr
    let default' typ = Expr.Default(typ) :> Expr
    let defaultT<'a> = default' typeof<'a>
    let null' = defaultT<System.Object>
  
    //Variables
    let var name typ = Expr.Variable(typ, name)
    let varT<'a> name = var name typeof<'a>
    let paramI i typ = Expr.Parameter(typ, sprintf "param%i" i)
    let paramIT<'a> i = paramI i typeof<'a>
    let param name typ = Expr.Parameter(typ, name)
    let paramT<'a> name = param name typeof<'a>
    let paramRef name (typ:System.Type) = Expr.Parameter(typ.MakeByRefType(), name)
    let paramRefT<'a> name = paramRef name typeof<'a>
    
    let constant value = Expr.Constant(value, value.GetType()) :> Expr
    let inline const' value = Expr.Constant(value, value.GetType()) :> Expr
    let return' label (value:Expr) = Expr.Return(label, value) :> Expr
    let returnVoid label = Expr.Return(label) :> Expr
    let assign (left:Expr) (right:Expr) = Expr.Assign(left, right) :> Expr
  
    //Constants
    let true'   = const' true
  