anchor.diff:  
   (**)
   and Prototypes = {
  -  Object : CommonObject
  -  Array : CommonObject
  -  Function : FunctionObject
  -  String : CommonObject
  -  Number : CommonObject
  -  Boolean : CommonObject
  -  Date : CommonObject
  -  RegExp : CommonObject
  -  Error: CommonObject
  -  EvalError : CommonObject
  -  RangeError : CommonObject
  -  ReferenceError : CommonObject
  -  SyntaxError : CommonObject
  -  TypeError : CommonObject
  -  URIError : CommonObject
  +  Object : CO
  +  Array : CO
  +  Function : FO
  +  String : CO
  +  Number : CO
  +  Boolean : CO
  +  Date : CO
  +  RegExp : CO
  +  Error: CO
  +  EvalError : CO
  +  RangeError : CO
  +  ReferenceError : CO
  +  SyntaxError : CO
  +  TypeError : CO
  +  URIError : CO
   }
   
   (**)
   and Constructors = {
  -  Object : FunctionObject
  -  Array : FunctionObject
  -  Function : FunctionObject
  -  String : FunctionObject
  -  Number : FunctionObject
  -  Boolean : FunctionObject
  -  Date : FunctionObject
  -  RegExp : FunctionObject
  -  Error : FunctionObject
  -  EvalError : FunctionObject
  -  RangeError : FunctionObject
  -  ReferenceError : FunctionObject
  -  SyntaxError : FunctionObject
  -  TypeError : FunctionObject
  -  URIError : FunctionObject
  +  Object : FO
  +  Array : FO
  +  Function : FO
  +  String : FO
  +  Number : FO
  +  Boolean : FO
  +  Date : FO
  +  RegExp : FO
  +  Error : FO
  +  EvalError : FO
  +  RangeError : FO
  +  ReferenceError : FO
  +  SyntaxError : FO
  +  TypeError : FO
  +  URIError : FO
   }
   
   (**)
  
positive.code: (*
  //
  *)
  and TypeConverter() =
  
    (**)
    static member ToBoxedValue(v:BoxedValue) = v
    static member ToBoxedValue(d:double) = BoxedValue.Box(d)
    static member ToBoxedValue(b:bool) = BoxedValue.Box(b)
    static member ToBoxedValue(s:string) = BoxedValue.Box(s)
    static member ToBoxedValue(o:CO) = BoxedValue.Box(o)
    static member ToBoxedValue(f:FO) = BoxedValue.Box(f)
    static member ToBoxedValue(c:Object) = BoxedValue.Box(c)
    static member ToBoxedValue(expr:Dlr.Expr) : Dlr.Expr = 
      Dlr.callStaticT<TypeConverter> "ToBoxedValue" [expr]
      
    (**)
    static member ToClrObject(d:double) : Object = box d
  
negative.code:         else d
  
    static member ToNumber(expr:Dlr.Expr) : Dlr.Expr = 
      Dlr.callStaticT<TC> "ToNumber" [expr]
  
    (**)
    static member ToInt32(d:double) : int32 = d |> uint32 |> int
    static member ToInt32(b:BV) : int32 = b |> TC.ToNumber |> TC.ToInt32
  
    (**)
    static member ToUInt32(d:double) : uint32 = d |> uint32 
    static member ToUInt32(b:BV) : uint32 = b |> TC.ToNumber |> TC.ToUInt32
  
    (**)
    static member ToUInt16(d:double) : uint16 = d |> uint32 |> uint16
    static member ToUInt16(b:BV) : uint16 = b |> TC.ToNumber |> TC.ToUInt16
  
    (**)
    static member ToInteger(d:double) : int32 = if d > 2147483647.0 then 2147483647 else d |> uint32 |> int
    static member ToInteger(b:BoxedValue) : int32 = b |> TC.ToNumber |> TC.ToInteger
      
    (**)
    static member ConvertTo (env:Dlr.Expr, expr:Dlr.Expr, t:Type) =
      if Object.ReferenceEquals(expr.Type, t) then expr
      elif t.IsAssignableFrom(expr.Type) then Dlr.cast t expr
      else 
        if   t = typeof<double> then TC.ToNumber expr
        elif t = typeof<string> then TC.ToString expr
        elif t = typeof<bool> then TC.ToBoolean expr
        elif t = typeof<BV> then TC.ToBoxedValue expr
        elif t = typeof<CO> then TC.ToObject(env, expr)
        elif t = typeof<obj> then TC.ToClrObject expr
        else Support.Errors.noConversion expr.Type t
      
  (**)
  