anchor.diff:  
                   type IEssenceOfGetHashCode<'a> =
                       abstract Ensorcel : IEqualityComparer * 'a -> int
  -
  -                [<Sealed>]
  -                type FlaconOfComparer<'a, 't when 't :> IEssenceOfCompareTo<'a> and 't : (new : unit -> 't)>() =
  -                    static let ``instance`` = new 't ()
  -                    static member Instance = ``instance``
  -
  -                [<Sealed>]
  -                type FlaconOfEquals<'a, 't when 't :> IEssenceOfEquals<'a> and 't : (new : unit -> 't)>() =
  -                    static let ``instance`` = new 't ()
  -                    static member Instance = ``instance``
  -
  -                [<Sealed>]
  -                type FlaconOfGetHashCode<'a, 't when 't :> IEssenceOfGetHashCode<'a> and 't : (new : unit -> 't)>() =
  -                    static let ``instance`` = new 't ()
  -                    static member Instance = ``instance``
   
                   module ComparerTypes =
                       let getPERNaNResult (comp:IComparer) =
  
positive.code:                     | r when r.Equals typeof<PartialEquivalenceRelation> -> null
                      | _ -> raise (Exception "invalid logic")
  
                  type GenericEqualityObj_ER<'a>() =
                      interface Specializations.IEssenceOfEquals<'a> with
                          member __.Ensorcel (ec:IEqualityComparer, x:'a, y:'a) =  GenericEqualityObj true ec (box x, box y)
                          
                  type GenericEqualityObj_PER<'a>() =
                      interface Specializations.IEssenceOfEquals<'a> with
                          member __.Ensorcel (ec:IEqualityComparer, x:'a, y:'a) = GenericEqualityObj false ec (box x, box y)
  
  
negative.code:                     end
  
                  [<Sealed>]
                  type EssenceOfCompareWrapper<'a, 'comp 
                          when 'comp  :> Specializations.IEssenceOfCompareTo<'a> and 'comp : (new : unit -> 'comp) and 'comp : struct>() =
                      inherit ComparerInvoker<'a>()
                  
                      override __.Invoke (comp, x:'a, y:'a) =
                          phantom<'comp>.Ensorcel (comp, x, y)
  
                  let makeComparerInvoker (ty:Type) comp =
                      let wrapperTypeDef = typedefof<EssenceOfCompareWrapper<int,Specializations.ComparerTypes.Int32>>
  