anchor.diff:          then FSharp.Seq.first exprs
           else Expr.Block(exprs) :> Expr
   
  -  let blockTmp type' (f:ExprParam -> Expr seq) =
  +  let blockTmp type' (f:Parameter -> Expr seq) =
       let tmp = param (tmpName()) type'
       block [tmp] (f tmp)
   
     let blockTmpT<'a> f =
       blockTmp typeof<'a> f
   
  -  let field expr (name:string) = Et.PropertyOrField(expr, name) :> Expr
  -  let fieldr (name:string) expr = Et.PropertyOrField(expr, name) :> Expr
  -
  -  let propertyInfoStatic (pi:PropertyInfo) = Et.Property(null, pi) :> Expr
  -  let property expr (name:string) = Et.PropertyOrField(expr, name) :> Expr
  -  let propertyr (name:string) expr = Et.PropertyOrField(expr, name) :> Expr
  -  let propertyStatic (type':System.Type) name = Et.Property(null, type', name) :> Expr
  +  let field expr (name:string) = Expr.PropertyOrField(expr, name) :> Expr
  +  let fieldr (name:string) expr = Expr.PropertyOrField(expr, name) :> Expr
  +
  +  let propertyInfoStatic (pi:PropertyInfo) = Expr.Property(null, pi) :> Expr
  +  let property expr (name:string) = Expr.PropertyOrField(expr, name) :> Expr
  +  let propertyr (name:string) expr = Expr.PropertyOrField(expr, name) :> Expr
  +  let propertyStatic (type':System.Type) name = Expr.Property(null, type', name) :> Expr
     let propertyStaticT<'a> = propertyStatic typeof<'a>
  -  let propertyOrField expr (name:string) = Et.PropertyOrField(expr, name) :> Expr
  +  let propertyOrField expr (name:string) = Expr.PropertyOrField(expr, name) :> Expr
   
     let private exprTypes (args:Expr seq) = [|for a in args -> a.Type|]
   
     let call (expr:Expr) name (args:Expr seq) =
       match FSharp.Reflection.getMethodArgs expr.Type name (exprTypes args) with
       | None -> failwith "No method found with matching name and arguments"
  -    | Some(method') -> Et.Call(expr, method', args) :> Expr
  +    | Some(method') -> Expr.Call(expr, method', args) :> Expr
   
     let callGeneric (expr:Expr) name typeArgs (args:Expr seq) =
       let exprTypes = (exprTypes args)
       match FSharp.Reflection.getMethodGeneric expr.Type name typeArgs exprTypes with
       | None -> 
         failwith "No method found with matching name, type args and arguments"
  -    | Some(method') -> Et.Call(expr, method', args) :> Expr
  +    | Some(method') -> Expr.Call(expr, method', args) :> Expr
   
     let callStatic (type':System.Type) name (args:Expr seq) =
       match FSharp.Reflection.getMethodArgs type' name (exprTypes args) with
       | None -> failwith "No method found with matching name and arguments"
  -    | Some(method') -> Et.Call(null, method', args) :> Expr
  +    | Some(method') -> Expr.Call(null, method', args) :> Expr
   
     let callStaticT<'a> = callStatic typeof<'a>
   
  
positive.code:   let loop break' continue' test body =
      loop_ test void' body break' continue'
  
    let sub left right = Et.Subtract(left, right) :> Et
    let subChk left right = Et.SubtractChecked(left, right) :> Et
    let subAsn left right = Et.SubtractAssign(left, right) :> Et
    let subAsnChk left right = Et.SubtractAssignChecked(left, right) :> Et
  
    let add left right = Et.Add(left, right) :> Et
    let addChk left right = Et.AddChecked(left, right) :> Et
    let addAsn left right = Et.AddAssign(left, right) :> Et
    let addAsnChk left right = Et.AddAssignChecked(left, right) :> Et
  
    let concat left right = callStaticT<System.String> "Concat" [left; right]
  
    let mul left right = Et.Multiply(left, right) :> Et
    let mulChk left right = Et.MultiplyChecked(left, right) :> Et
    let mulAsn left right = Et.MultiplyAssign(left, right) :> Et
    let mulAsnChk left right = Et.MultiplyAssignChecked(left, right) :> Et
  
    let div left right = Et.Divide(left, right) :> Et
    let divAsn left right = Et.DivideAssign(left, right) :> Et
  
    let pow left right = Et.Power(left, right) :> Et
    let powAsn left right = Et.PowerAssign(left, right) :> Et
  
    let mod' left right = Et.Modulo(left, right) :> Et
    let modAsn left right = Et.ModuloAssign(left, right) :> Et
  
    let or' left right = Et.OrElse(left, right) :> Et
    let orChain (c:Et list) = 
      match c with
      | [] -> true'
      | _  -> List.fold (fun s x -> or' s x) c.Head c.Tail 
  
    let and' left right = Et.AndAlso(left, right) :> Et
    let andChain (c:Et list) = 
      match c with
      | [] -> true'
      | _  -> List.fold (fun s x -> and' s x) c.Head c.Tail
  
    let is' typ target = Et.TypeIs(target, typ) :> Et
    let isT<'a> = is' typeof<'a> 
  
    let typeEq target typ = Et.TypeEqual(target, typ) :> Et
  
    let refEq left right = Et.ReferenceEqual(left, right) :> Et
    let refNotEq left right = Et.ReferenceNotEqual(left, right) :> Et
  
    let eq left right = Et.Equal(left, right) :> Et
    let notEq left right = Et.NotEqual(left, right) :> Et
  
    let lt left right = Et.LessThan(left, right) :> Et
    let ltEq left right = Et.LessThanOrEqual(left, right) :> Et
  
    let gt left right = Et.GreaterThan(left, right) :> Et
    let gtEq left right = Et.GreaterThanOrEqual(left, right) :> Et
  
    let not target = Et.OnesComplement target :> Et
    let notDefault target = notEq target (default' target.Type)
  
    let isFalse target = Et.IsFalse(target) :> Et
    let isTrue target = Et.IsTrue(target) :> Et
  
    let isDefault ex = eq ex (default' ex.Type)
    let isNull = isDefault
  
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())
  