anchor.diff:          //-------------------------------------------------------------------------
           // LanguagePrimitives: PUBLISH IEqualityComparer AND IComparer OBJECTS
           //------------------------------------------------------------------------- 
  +
   
           let inline MakeGenericEqualityComparer<'T>() = 
               // type-specialize some common cases to generate more efficient functions 
               { new System.Collections.Generic.IEqualityComparer<'T> with 
                     member self.GetHashCode(x) = GenericHash x 
                     member self.Equals(x,y) = GenericEquality x y }
  -
  -        let inline MakeGenericEqualityComparerWithEssence<'T>() : IEqualityComparer<'T> =
  -            unboxPrim (HashCompare.makeEqualityComparer typeof<'T>)
   
           let inline MakeGenericLimitedEqualityComparer<'T>(limit:int) = 
               // type-specialize some common cases to generate more efficient functions 
  
positive.code:             // The compiler optimizer is aware of this function (see use of generic_equality_er_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T".
              let GenericEqualityERIntrinsic (x : 'T) (y : 'T) : bool =
                  eliminate_tail_call_bool (GenericSpecializeEquals.Function<EquivalenceRelation,_>.Invoker.Invoke (fsEqualityComparerNoHashingER, x, y))
                  
              /// Implements generic equality between two values using "comp" for recursive calls.
              //
              // The compiler optimizer is aware of this function  (see use of generic_equality_withc_inner_vref in opt.fs)
              // and devirtualizes calls to it based on "T", and under the assumption that "comp" 
              // is either fsEqualityComparerNoHashingER or fsEqualityComparerNoHashingPER.
              //
              // <<manofstick>> I think the above compiler optimization is misplaced, as it means that you can end
              // up with differing functionality of generic and non-generic types when the IStructuralEquatable
              // this is doucmented here- https://github.com/Microsoft/visualfsharp/pull/513#issuecomment-117995410
              let GenericEqualityWithComparerIntrinsic (comp : System.Collections.IEqualityComparer) (x : 'T) (y : 'T) : bool =
                  match comp with
                  | :? IEqualityComparerInfo as info ->
                      match info.Info with
                      | EqualityComparerInfo.ER  -> eliminate_tail_call_bool (GenericEqualityERIntrinsic x y)
                      | EqualityComparerInfo.PER -> eliminate_tail_call_bool (GenericEqualityIntrinsic x y)
                      | _ -> raise (Exception "invalid logic")
                  | c when obj.ReferenceEquals (c, EqualityComparer<'T>.Default)   ->
                      eliminate_tail_call_bool (EqualityComparer<'T>.Default.Equals (x, y))
                  | _ ->
                      eliminate_tail_call_bool (comp.Equals (box x, box y))
  
              /// Implements generic equality between two values, with ER semantics for NaN (so equality on two NaN values returns true)
              //
  
negative.code:         let Float32IEquality = MakeGenericEqualityComparer<float32>()
          let DecimalIEquality = MakeGenericEqualityComparer<decimal>()
  
          [<CodeAnalysis.SuppressMessage("Microsoft.Performance","CA1812:AvoidUninstantiatedInternalClasses")>]     
          type FastGenericEqualityComparerTable<'T>() = 
              static let f : System.Collections.Generic.IEqualityComparer<'T> = 
                  match typeof<'T> with 
                  | ty when ty.Equals(typeof<bool>)       -> unboxPrim (box BoolIEquality)
                  | ty when ty.Equals(typeof<byte>)       -> unboxPrim (box ByteIEquality)
                  | ty when ty.Equals(typeof<int32>)      -> unboxPrim (box Int32IEquality)
                  | ty when ty.Equals(typeof<uint32>)     -> unboxPrim (box UInt32IEquality)
                  | ty when ty.Equals(typeof<char>)       -> unboxPrim (box CharIEquality)
                  | ty when ty.Equals(typeof<sbyte>)      -> unboxPrim (box SByteIEquality)
                  | ty when ty.Equals(typeof<int16>)      -> unboxPrim (box Int16IEquality)
                  | ty when ty.Equals(typeof<int64>)      -> unboxPrim (box Int64IEquality)
                  | ty when ty.Equals(typeof<nativeint>)  -> unboxPrim (box IntPtrIEquality)
                  | ty when ty.Equals(typeof<uint16>)     -> unboxPrim (box UInt16IEquality)
                  | ty when ty.Equals(typeof<uint64>)     -> unboxPrim (box UInt64IEquality)
                  | ty when ty.Equals(typeof<unativeint>) -> unboxPrim (box UIntPtrIEquality)
                  | ty when ty.Equals(typeof<float>)      -> unboxPrim (box FloatIEquality)
                  | ty when ty.Equals(typeof<float32>)    -> unboxPrim (box Float32IEquality)
                  | ty when ty.Equals(typeof<decimal>)    -> unboxPrim (box DecimalIEquality)
                  | ty when ty.Equals(typeof<string>)     -> unboxPrim (box StringIEquality)
                  | _ -> MakeGenericEqualityComparer<'T>()
              static member Function : System.Collections.Generic.IEqualityComparer<'T> = f
  
          let FastGenericEqualityComparerFromTable<'T> = FastGenericEqualityComparerTable<'T>.Function
  