anchor.diff:    let newGenericArgsT<'a> = newGenericArgs typedefof<'a> 
   
     let delegateType (types:System.Type seq) = 
  -    Et.GetDelegateType(Seq.toArray types)
  +    Expr.GetDelegateType(Seq.toArray types)
       
  -  let lambda (typ:System.Type) (parms:EtParam seq) body = 
  -    Et.Lambda(typ, body, parms)
  -
  -  let lambdaT<'a> (parms:EtParam seq) (body:Et) = Et.Lambda<'a>(body, parms)
  -  let lambdaAuto (parms:EtParam seq) (body:Et) = Et.Lambda(body, parms)
  -
  -  let invoke (func:Et) (args:Et seq) = Et.Invoke(func, args) :> Et
  -
  -  let dynamic typ binder (args:Et seq) = Et.Dynamic(binder, typ, args) :> Et
  +  let lambda (typ:System.Type) (parms:Parameter seq) body = 
  +    Expr.Lambda(typ, body, parms)
  +
  +  let lambdaT<'a> (parms:Parameter seq) (body:Expr) = Expr.Lambda<'a>(body, parms)
  +  let lambdaAuto (parms:Parameter seq) (body:Expr) = Expr.Lambda(body, parms)
  +
  +  let invoke (func:Expr) (args:Expr seq) = Expr.Invoke(func, args) :> Expr
  +
  +  let dynamic typ binder (args:Expr seq) = Expr.Dynamic(binder, typ, args) :> Expr
     let dynamicT<'a> = dynamic typeof<'a>
   
  -  let length target = Et.ArrayLength(target) :> Et
  +  let length target = Expr.ArrayLength(target) :> Expr
   
     let item (expr:Expr) index = 
       let item = expr.Type.GetProperty("Item")
       Expr.MakeIndex(expr, item, [const' index]) :> Expr
   
  -  let index target (exprs:Et seq) = Et.ArrayAccess(target, exprs) :> Expr
  +  let index target (exprs:Expr seq) = Expr.ArrayAccess(target, exprs) :> Expr
     let indexInts target indexes = index target (indexes |> Seq.map (fun (x:int) -> const' x))
     let indexInt target index = indexInts target [index]
     let index0 target = index target [const' 0]
     let index1 target = index target [const' 1]
     let index2 target = index target [const' 2]
   
  -  let newArray typ (bounds:Et seq) = Et.NewArrayBounds(typ, bounds) :> Expr
  +  let newArray typ (bounds:Expr seq) = Expr.NewArrayBounds(typ, bounds) :> Expr
     let newArrayT<'a> = new' typeof<'a>
   
  -  let newArrayItems typ (exprs:Et seq) = Et.NewArrayInit(typ, exprs) :> Expr
  +  let newArrayItems typ (exprs:Expr seq) = Expr.NewArrayInit(typ, exprs) :> Expr
     let newArrayItemsT<'a> = newArrayItems typeof<'a>
   
     let newArrayBounds typ (size:Expr) = Expr.NewArrayBounds(typ, size) :> Expr
  
positive.code:   let dbl1 = const' 1.0
    let dbl2 = const' 2.0
  
    let label (typ:System.Type) name = Et.Label(typ, name)
    let labelVoid = label typeof<System.Void>
    let labelT<'a> = label typeof<'a>
    let labelExpr label (typ:System.Type) = Et.Label(label, Et.Default(typ)) :> Et
    let labelExprT<'a> label = labelExpr label typeof<'a>
    let labelExprVal label (value:Et) = Et.Label(label, value) :> Et
    let labelExprVoid label = labelExprVal label (default' typeof<System.Void>)
    let labelBreak () = labelVoid "break"
    let labelContinue () = labelVoid "continue"
  
negative.code:     let local name type' = Expr.Variable(type', name)
      let localT<'a> name = var name typeof<'a>
      
      let param name type' = Expr.Parameter(type', name)
      let paramT<'a> name = param name typeof<'a>
  
      let paramRef name (type':Type) = param name (type'.MakeByRefType())
  