anchor.diff:    module Logic =
       let or' left right = Et.OrElse(left, right) :> Et
       let and' left right = Et.AndAlso(left, right) :> Et
  +    let not target = Et.OnesComplement target :> Et
   
       let is' typ target = Et.TypeIs(target, typ) :> Et
       let isT<'a> = is' typeof<'a> 
  
positive.code:   let new' (typ:System.Type) = Et.New(typ) :> Et
    let newT<'a> = new' typeof<'a>
  
    let newGeneric (typ:System.Type) (types:ClrType seq) = new' (typ.MakeGenericType(Seq.toArray types))
    let newGenericT<'a> = newGeneric typedefof<'a>
  
    let newArgs (typ:System.Type) (args:Et seq) = Et.New(Tools.Type.getCtor typ [for arg in args -> arg.Type], args) :> Et
    let newArgsT<'a> (args:Et seq) = newArgs typeof<'a>
  
    let newGenericArgs (typ:System.Type) (types:ClrType seq) (args:Et seq) = newArgs (typ.MakeGenericType(Seq.toArray types)) args
    let newGenericArgsT<'a> = newGenericArgs typedefof<'a> 
  
    let delegateType (types:ClrType seq) = Et.GetDelegateType(Seq.toArray types)
    let lambda (typ:ClrType) (parms:EtParam seq) (body:Et) = Et.Lambda(typ, 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
  
negative.code:     let catchT<'a> = catch typeof<'a>
  
    module Bit =
      let and' left right = Et.And(left, right) :> Et
      let andAsn left right = Et.AndAssign(left, right) :> Et
  
      let or' left right = Et.Or(left, right) :> Et
      let orAsn left right = Et.OrAssign(left, right) :> Et
  
      let xor left right = Et.ExclusiveOr(left, right) :> Et
      let xorAsn left right = Et.ExclusiveOrAssign(left, right) :> Et
  
      let rhs left right = Et.RightShift(left, right) :> Et
      let rhsAsn left right = Et.RightShiftAssign(left, right) :> Et
  
      let lhs left right = Et.LeftShift(left, right) :> Et
      let lhsAsn left right = Et.LeftShiftAssign(left, right) :> Et
  
      let not target = (Et.Not target) :> Et
  
    module Math =
      let sub left right = Et.Subtract(left, right) :> Et
  