anchor.diff:                      else null
   *)
                   
  -                let getEssenceOfGetHashCodeObj ty =
  +                let getEssenceOfGetHashCodeType ty =
                       let x = typedefof<GenericSpecializeHash.Function<_>>
                       let o = x.MakeGenericType [|ty|]
                       match Activator.CreateInstance o with
  -                    | :? GenericSpecializeHash.IGetEssenceOfGetHashCodeObj as getter -> getter.Get ()
  +                    | :? GenericSpecializeHash.IGetEssenceOfGetHashCodeType as getter -> getter.Get ()
                       | _ -> raise (Exception "invalid logic")
   
  -                let getEssenceOfEqualsObj ty =
  +                let getEssenceOfEqualsType ty =
                       let x = typedefof<GenericSpecializeEquals.Function<_,_>>
                       let o = x.MakeGenericType [|typeof<EquivalenceRelation>; ty|]
                       match Activator.CreateInstance o with
  -                    | :? GenericSpecializeEquals.IGetEssenceOfEqualsObj as getter -> getter.Get ()
  -                    | _ -> raise (Exception "invalid logic")
  -
  -                let getEssenceOfCompareToObj ty =
  -                    let x = typedefof<GenericSpecializeCompareTo.Function<_,_>>
  -                    let o = x.MakeGenericType [|typeof<EquivalenceRelation>; ty|]
  -                    match Activator.CreateInstance o with
  -                    | :? GenericSpecializeCompareTo.IGetEssenceOfComparerObj as getter -> getter.Get ()
  +                    | :? GenericSpecializeEquals.IGetEssenceOfEqualsType as getter -> getter.Get ()
                       | _ -> raise (Exception "invalid logic")
   
                   type t = Specializations.GetHashCodeTypes.Int32
  
positive.code:                         fun () -> defaultGetHashCode t
                      |]
                              
                  type IGetEssenceOfGetHashCodeObj =
                      abstract Get : unit -> obj
                              
                  type Function<'a>() =
                      static let func : Specializations.IEssenceOfGetHashCode<'a> =
  
negative.code:                             let t0 = (get tyDefArgs 0)
                              let t1 = (get tyDefArgs 1)
                              let t2 = (get tyDefArgs 2)
                              let ghc0 = (getEssenceOfGetHashCodeType t0)
                              let ghc1 = (getEssenceOfGetHashCodeType t1)
                              let ghc2 = (getEssenceOfGetHashCodeType t2)
  
                              let tt = typedefof<TupleEssenceOfGetHashCode<int,int,int,t,t,t>>
                              let zz = tt.MakeGenericType [| t0; t1; t2; ghc0; ghc1; ghc2 |] 
  