anchor.diff:  
                   [<Sealed>]
                   type EssenceOfGetHashCodeWrapper<'a, 'ghc
  -                         when 'ghc :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc : (new : unit -> 'ghc)>() =
  +                         when 'ghc :> Specializations.IEssenceOfGetHashCode<'a> and 'ghc : (new : unit -> 'ghc) and 'ghc : struct>() =
                       inherit GetHashCodeInvoker<'a>()
                   
                       override __.Invoke (comp, x:'a) =
  -                        Specializations.FlaconOfGetHashCode<'a,'ghc>.Instance.Ensorcel (comp, x)
  +                        phantom<'ghc>.Ensorcel (comp, x)
   
                   let makeGetHashCodeWrapper (ty:Type) comp =
                       let wrapperTypeDef = typedefof<EssenceOfGetHashCodeWrapper<int,Specializations.GetHashCodeTypes.Int32>>
  
positive.code:                     | r when r.Equals typeof<PartialEquivalenceRelation> -> null
                      | _ -> raise (Exception "invalid logic")
  
                  type GenericComparerObj<'a>() =
                      interface Specializations.IEssenceOfCompareTo<'a> with
                          member __.Ensorcel (comp:IComparer, x:'a, y:'a) = comp.Compare (box x, box y)
  
  
negative.code:                             | null, _ -> -1
                              | _, null -> +1
                              | _, _ ->
                                  eliminate_tail_call_int (phantom<'comp1>.Ensorcel (comparer, x.Item1, y.Item1))
  
                  [<Struct; NoComparison; NoEquality>]
                  type TupleEssenceOfCompareTo<'a,'b,
                                                  'comp1,'comp2
                                                      when 'comp1 :> Specializations.IEssenceOfCompareTo<'a> and 'comp1 : (new : unit -> 'comp1) and 'comp1 : struct
                                                       and 'comp2 :> Specializations.IEssenceOfCompareTo<'b> and 'comp2 : (new : unit -> 'comp2) and 'comp2 : struct
                                                                                                                                                                      > =
                      interface Specializations.IEssenceOfCompareTo<System.Tuple<'a,'b>> with
                          member __.Ensorcel (comparer:IComparer, x:System.Tuple<'a,'b>, y:System.Tuple<'a,'b>) = 
                              match x, y with
  