anchor.diff:              { new System.Collections.Generic.IComparer<'T> with 
                    member __.Compare(x,y) = GenericComparison x y }
   
  -        let inline MakeGenericComparerWithEssence<'T>() : IComparer<'T> = 
  -            unboxPrim (HashCompare.makeComparer typeof<'T>)
  -
           let CharComparer    = MakeGenericComparer<char>()
           let StringComparer  = MakeGenericComparer<string>()
           let SByteComparer   = MakeGenericComparer<sbyte>()
  
positive.code:             // NOTE: the compiler optimizer is aware of this function and devirtualizes in the 
              // cases where it is known how a particular type implements generic comparison.
              let GenericComparisonWithComparerIntrinsic<'T> (comp:System.Collections.IComparer) (x:'T) (y:'T) : int = 
                  match comp with
                  | :? GenericComparer as info ->
                      match info.ComparerType with
                      | ComparerType.ER     -> eliminate_tail_call_int (GenericSpecializeCompareTo.Function<EquivalenceRelation,_>.Invoker.Invoke (comp, x, y))
                      | ComparerType.PER_gt 
                      | ComparerType.PER_lt -> eliminate_tail_call_int (GenericComparisonForInequality comp x y)
                      | _ -> raise (Exception "invalid logic")
                  | c when obj.ReferenceEquals (c, Comparer<'T>.Default)   ->
                      eliminate_tail_call_int (Comparer<'T>.Default.Compare (x, y))
                  | _ ->
                      eliminate_tail_call_int (comp.Compare (box x, box y))
  
              /// Generic comparison. Implements ER mode (where "0" is returned when NaNs are compared)
              //
              // The compiler optimizer is aware of this function  (see use of generic_comparison_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T".
              let GenericComparisonIntrinsic<'T> (x:'T) (y:'T) : int = 
                  eliminate_tail_call_int (GenericSpecializeCompareTo.Function<EquivalenceRelation,_>.Invoker.Invoke (fsComparerER, x, y))
  
              /// Generic less-than. Uses comparison implementation in PER mode but catches 
              /// the local exception that is thrown when NaN's are compared.
              let GenericLessThanIntrinsic (x:'T) (y:'T) = 
                  (# "clt" (GenericComparisonForInequality fsComparerPER_lt x y) 0 : bool #)
              
              /// Generic greater-than. Uses comparison implementation in PER mode but catches 
              /// the local exception that is thrown when NaN's are compared.
              let GenericGreaterThanIntrinsic (x:'T) (y:'T) = 
                  (# "cgt" (GenericComparisonForInequality fsComparerPER_gt x y) 0 : bool #)
               
              /// Generic greater-than-or-equal. Uses comparison implementation in PER mode but catches 
              /// the local exception that is thrown when NaN's are compared.
              let GenericGreaterOrEqualIntrinsic (x:'T) (y:'T) = 
                  (# "cgt" (GenericComparisonForInequality fsComparerPER_gt x y) (-1) : bool #)
              
              /// Generic less-than-or-equal. Uses comparison implementation in PER mode but catches 
              /// the local exception that is thrown when NaN's are compared.
              let GenericLessOrEqualIntrinsic (x:'T) (y:'T) = 
                  (# "clt" (GenericComparisonForInequality fsComparerPER_lt x y) 1 : bool #)
  
              /// Compare two values of the same generic type, in either PER or ER mode, but include static optimizations
              /// for various well-known cases.
  
negative.code:             type GenericComparer with
                  interface System.Collections.IComparer with
                      override c.Compare(x:obj,y:obj) = GenericCompare c (x,y)
              
              /// The unique object for comparing values in PER mode (where local exceptions are thrown when NaNs are compared)
              let fsComparerPER        = GenericComparer(true)  
  
              /// The unique object for comparing values in ER mode (where "0" is returned when NaNs are compared)
              let fsComparerER = GenericComparer(false) 
                      
              /// Compare two values of the same generic type, using "comp".
              //
              // "comp" is assumed to be either fsComparerPER or fsComparerER (and hence 'Compare' is implemented via 'GenericCompare').
  