anchor.diff:                      let wrapperType = wrapperTypeDef.MakeGenericType [| ty; comp |]
                       Activator.CreateInstance wrapperType
   
  +                type u = Specializations.EqualsTypes.Int32
                   type Function<'relation, 'a>() =
                       static let essenceType : Type =
  -                        getEqualsEssenceType typeof<'relation> typeof<'a>
  +                        getEqualsEssenceType typeof<'relation> typeof<'a> Helpers.tuplesEquals
   
                       static let invoker : EqualsInvoker<'a> =
                           unboxPrim (makeEqualsWrapper typeof<'a> essenceType)
  
positive.code:                     member __.Info = EqualityComparerInfo.ER }
  
              module GenericSpecializeEquals =
                  let mutable private tupleHandler = null
                  let addTupleHandler f =
                      match box tupleHandler with
                      | null -> tupleHandler <- f
                      | _ -> raise (Exception "invalid logic")
  
                  let tuples tyRelation ty =
                      match box tupleHandler with
                      | :? (Type -> Type -> Type) as handler -> handler tyRelation ty
                      | _ -> null
  
                  let floatingPointTypes (tyRelation:Type) (ty:Type) =
                      match tyRelation with
                      | r when r.Equals typeof<PartialEquivalenceRelation> ->
  
negative.code: 
                      interface mos.IGetType with
                          member __.Get () = essenceType
                  and Helpers =
                      static member getEssenceOfEqualsType tyRelation ty =
                          let equals = mos.makeGenericType<Function<_,_>> [| tyRelation; ty|]
                          match Activator.CreateInstance equals with
                          | :? mos.IGetType as getter -> getter.Get ()
                          | _ -> raise (Exception "invalid logic")
  
                      static member tuplesEquals (tyRelation:Type) (ty:Type) : Type =
                          if ty.IsGenericType then
                              let tyDef = ty.GetGenericTypeDefinition ()
                              let tyDefArgs = ty.GetGenericArguments ()
                              let create = mos.compositeType (Helpers.getEssenceOfEqualsType tyRelation) tyDefArgs
                              if   tyDef.Equals typedefof<Tuple<_>>               then create typedefof<TupleEquals.TupleEssenceOfEquals<int,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_>>             then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_>>           then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_>>         then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_>>       then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,u,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,int,u,u,u,u,u,u,u>>
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<TupleEquals.TupleEssenceOfEquals<int,int,int,int,int,int,int,int,u,u,u,u,u,u,u,u>>
                              else null
                          else null
  
  
              /// Implements generic equality between two values, with PER semantics for NaN (so equality on two NaN values returns false)
              //
  