anchor.diff:  
               [<Sealed>]
               type EssenceOfComparer<'a, 'comp
  -                    when 'comp  :> Specializations.IEssenceOfCompareTo<'a> and 'comp : (new : unit -> 'comp) and 'comp : struct>() =
  +                    when 'comp  :> IEssenceOfCompareTo<'a> and 'comp : (new : unit -> 'comp) and 'comp : struct>() =
                   
                   interface IComparer<'a> with
                       member __.Compare (x:'a, y:'a) =
  
positive.code:                                 | _, null -> +1
                                  | _, _ -> x.CompareTo y
  
                      [<Struct; NoComparison; NoEquality>]
                      type StructuralEquatable<'a when 'a : not struct and 'a : null and 'a :> IStructuralEquatable> =
                          interface Specializations.IEssenceOfEquals<'a> with
                              member __.Ensorcel (ec:IEqualityComparer, x:'a, y:'a) =
                                  match x, y with
                                  | null, null -> true
                                  | null, _ | _, null -> false
                                  | _, _ -> x.Equals (box y, ec) 
  
                          interface Specializations.IEssenceOfGetHashCode<'a> with
                              member __.Ensorcel (ec:IEqualityComparer, x:'a) =
                                  match x with
                                  | null -> 0
  
negative.code:             let makeEqualityComparer (ty:Type) =
                  let eq = GenericSpecializeEquals.Helpers.getEssenceOfEqualsType typeof<PartialEquivalenceRelation> ty
                  let ghc = GenericSpecializeHash.Helpers.getEssenceOfGetHashCodeType typeof<PartialEquivalenceRelation> ty
                  let equalityComparerDef = typedefof<EssenceOfEqualityComparer<int,EqualsTypes.Int32,GetHashCodeTypes.Int32>>
                  let equalityComparer = equalityComparerDef.MakeGenericType [| ty; eq; ghc |]
                  Activator.CreateInstance equalityComparer
  
              let makeComparer (ty:Type) =
                  let comp = GenericSpecializeCompareTo.Helpers.getEssenceOfCompareToType typeof<EquivalenceRelation> ty
                  let comparerDef = typedefof<EssenceOfComparer<int,ComparerTypes.Int32>>
                  let comparer = comparerDef.MakeGenericType [| ty; comp |]
                  Activator.CreateInstance comparer
                  
  