anchor.diff:                  [<Struct; NoComparison; NoEquality>] type Decimal    = interface IEssenceOfCompareTo<decimal   > with member __.Ensorcel (_,x,y) = System.Decimal.Compare((# "" x:decimal #), (# "" y:decimal #))
   
                   [<Struct; NoComparison; NoEquality>]
  -                type Tuple<'a,
  -                            'comp1
  -                                when 'comp1 :> IEssenceOfCompareTo<'a> and 'comp1 : (new : unit -> 'comp1) and 'comp1 : struct
  -                                                                                                                                > =
  -                    interface IEssenceOfCompareTo<System.Tuple<'a>> with
  -                        member __.Ensorcel (comparer:IComparer, x:System.Tuple<'a>, y:System.Tuple<'a>) = 
  -                            match x, y with
  -                            | null, null -> 0
  -                            | null, _ -> -1
  -                            | _, null -> +1
  -                            | _, _ ->
  -                                eliminate_tail_call_int (phantom<'comp1>.Ensorcel (comparer, x.Item1, y.Item1))
  -
  -                [<Struct; NoComparison; NoEquality>]
                   type Tuple<'a,'b,
                               'comp1,'comp2
                                   when 'comp1 :> IEssenceOfCompareTo<'a> and 'comp1 : (new : unit -> 'comp1) and 'comp1 : struct
  
positive.code:                                 | _ ->
                                  phantom<'eq5>.Ensorcel (ec, x.Item5, y.Item5)
  
                  [<Struct; NoComparison; NoEquality>]
                  type Tuple<'a,'b,'c,'d,'e,'f,
                              'eq1,'eq2,'eq3,'eq4,'eq5,'eq6
                                  when 'eq1 :> IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1) and 'eq1 : struct
                                      and 'eq2 :> IEssenceOfEquals<'b> and 'eq2 : (new : unit -> 'eq2) and 'eq2 : struct
                                      and 'eq3 :> IEssenceOfEquals<'c> and 'eq3 : (new : unit -> 'eq3) and 'eq3 : struct
                                      and 'eq4 :> IEssenceOfEquals<'d> and 'eq4 : (new : unit -> 'eq4) and 'eq4 : struct
                                      and 'eq5 :> IEssenceOfEquals<'e> and 'eq5 : (new : unit -> 'eq5) and 'eq5 : struct
                                      and 'eq6 :> IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6) and 'eq6 : struct
                                                                                                                      > =
                      interface IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f>, y:System.Tuple<'a,'b,'c,'d,'e,'f>) = 
                              match x, y with
                              | null, null -> true
                              | null, _ | _, null -> false
                              | _, _ ->
                                  match phantom<'eq1>.Ensorcel (ec, x.Item1, y.Item1) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq2>.Ensorcel (ec, x.Item2, y.Item2) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq3>.Ensorcel (ec, x.Item3, y.Item3) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq4>.Ensorcel (ec, x.Item4, y.Item4) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq5>.Ensorcel (ec, x.Item5, y.Item5) with
                                  | false -> false
                                  | _ ->
                                  phantom<'eq6>.Ensorcel (ec, x.Item6, y.Item6)
  
                  [<Struct; NoComparison; NoEquality>]
                  type Tuple<'a,'b,'c,'d,'e,'f,'g,
                              'eq1,'eq2,'eq3,'eq4,'eq5,'eq6,'eq7
                                  when 'eq1 :> IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1) and 'eq1 : struct
                                      and 'eq2 :> IEssenceOfEquals<'b> and 'eq2 : (new : unit -> 'eq2) and 'eq2 : struct
                                      and 'eq3 :> IEssenceOfEquals<'c> and 'eq3 : (new : unit -> 'eq3) and 'eq3 : struct
                                      and 'eq4 :> IEssenceOfEquals<'d> and 'eq4 : (new : unit -> 'eq4) and 'eq4 : struct
                                      and 'eq5 :> IEssenceOfEquals<'e> and 'eq5 : (new : unit -> 'eq5) and 'eq5 : struct
                                      and 'eq6 :> IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6) and 'eq6 : struct
                                      and 'eq7 :> IEssenceOfEquals<'g> and 'eq7 : (new : unit -> 'eq7) and 'eq7 : struct
                                                                                                                      > =
                      interface IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f,'g>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g>, y:System.Tuple<'a,'b,'c,'d,'e,'f,'g>) = 
                              match x, y with
                              | null, null -> true
                              | null, _ | _, null -> false
                              | _, _ ->
                                  match phantom<'eq1>.Ensorcel (ec, x.Item1, y.Item1) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq2>.Ensorcel (ec, x.Item2, y.Item2) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq3>.Ensorcel (ec, x.Item3, y.Item3) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq4>.Ensorcel (ec, x.Item4, y.Item4) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq5>.Ensorcel (ec, x.Item5, y.Item5) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq6>.Ensorcel (ec, x.Item6, y.Item6) with
                                  | false -> false
                                  | _ ->
                                  phantom<'eq7>.Ensorcel (ec, x.Item7, y.Item7)
  
                  [<Struct; NoComparison; NoEquality>]
                  type Tuple<'a,'b,'c,'d,'e,'f,'g,'h,
                              'eq1,'eq2,'eq3,'eq4,'eq5,'eq6,'eq7,'eq8
                                  when 'eq1 :> IEssenceOfEquals<'a> and 'eq1 : (new : unit -> 'eq1) and 'eq1 : struct
                                      and 'eq2 :> IEssenceOfEquals<'b> and 'eq2 : (new : unit -> 'eq2) and 'eq2 : struct
                                      and 'eq3 :> IEssenceOfEquals<'c> and 'eq3 : (new : unit -> 'eq3) and 'eq3 : struct
                                      and 'eq4 :> IEssenceOfEquals<'d> and 'eq4 : (new : unit -> 'eq4) and 'eq4 : struct
                                      and 'eq5 :> IEssenceOfEquals<'e> and 'eq5 : (new : unit -> 'eq5) and 'eq5 : struct
                                      and 'eq6 :> IEssenceOfEquals<'f> and 'eq6 : (new : unit -> 'eq6) and 'eq6 : struct
                                      and 'eq7 :> IEssenceOfEquals<'g> and 'eq7 : (new : unit -> 'eq7) and 'eq7 : struct
                                      and 'eq8 :> IEssenceOfEquals<'h> and 'eq8 : (new : unit -> 'eq8) and 'eq8 : struct
                                                                                                                      > =
                      interface IEssenceOfEquals<System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>> with
                          member __.Ensorcel (ec:IEqualityComparer, x:System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>, y:System.Tuple<'a,'b,'c,'d,'e,'f,'g,'h>) = 
                              match x, y with
                              | null, null -> true
                              | null, _ | _, null -> false
                              | _, _ ->
                                  match phantom<'eq1>.Ensorcel (ec, x.Item1, y.Item1) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq2>.Ensorcel (ec, x.Item2, y.Item2) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq3>.Ensorcel (ec, x.Item3, y.Item3) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq4>.Ensorcel (ec, x.Item4, y.Item4) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq5>.Ensorcel (ec, x.Item5, y.Item5) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq6>.Ensorcel (ec, x.Item6, y.Item6) with
                                  | false -> false
                                  | _ ->
                                  match phantom<'eq7>.Ensorcel (ec, x.Item7, y.Item7) with
                                  | false -> false
                                  | _ ->
                                  phantom<'eq8>.Ensorcel (ec, x.Rest, y.Rest)
  
              module GetHashCodeTypes =
                  [<Struct; NoComparison; NoEquality>] type Bool       = interface IEssenceOfGetHashCode<bool      > with member __.Ensorcel (_,a) = a.GetHashCode()
                  [<Struct; NoComparison; NoEquality>] type Float      = interface IEssenceOfGetHashCode<float     > with member __.Ensorcel (_,a) = a.GetHashCode()
  
negative.code:                             let tyDef = ty.GetGenericTypeDefinition ()
                              let tyDefArgs = ty.GetGenericArguments ()
                              let create = mos.compositeType (Helpers.getEssenceOfCompareToType tyRelation) tyDefArgs
                              if   tyDef.Equals typedefof<Tuple<_,_>>       then create typedefof<ComparerTypes.Tuple<int,int,t,t>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_>>     then create typedefof<ComparerTypes.Tuple<int,int,int,t,t,t>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_>>   then create typedefof<ComparerTypes.Tuple<int,int,int,int,t,t,t,t>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>> then create typedefof<ComparerTypes.Tuple<int,int,int,int,int,t,t,t,t,t>> 
                              else null
                          else null
  
  