anchor.diff:                          let equatable = mos.makeEquatableType underlying
                           let make = mos.makeType underlying 
                           
  -                        if typeof<IStructuralEquatable>.IsAssignableFrom underlying then make Exemplars.nullableStructuralEquatable
  -                        elif equatable.IsAssignableFrom underlying                  then make Exemplars.nullableEquatable
  -                        else                                                             make Exemplars.nullableEquality
  +                        if typeof<IStructuralEquatable>.IsAssignableFrom underlying then make typedefof<CommonEqualityTypes.Nullable. StructuralEquatable<DummyValueType>>
  +                        elif equatable.IsAssignableFrom underlying                  then make typedefof<CommonEqualityTypes.Nullable.Equatable<int>>
  +                        else                                                             make typedefof<CommonEqualityTypes.Nullable.Equality<int>>
                       else null
   
                   let equalityInterfaces (t:Type) : Type =
                       let make = mos.makeType t
                       let equatable = mos.makeEquatableType t
   
  -                    if   t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t then make Exemplars.valueTypeStructuralEquatable
  -                    elif t.IsValueType && equatable.IsAssignableFrom t                    then make Exemplars.valueTypeEquatable
  -                    elif t.IsValueType                                                    then make Exemplars.valueTypeEquality
  -
  -                    elif typeof<IStructuralEquatable>.IsAssignableFrom t                  then make Exemplars.refTypeStructuralEquatable
  +                    if   t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t then make typedefof<CommonEqualityTypes.ValueType.StructuralEquatable<DummyValueType>>
  +                    elif t.IsValueType && equatable.IsAssignableFrom t                    then make typedefof<CommonEqualityTypes.ValueType.Equatable<int>>
  +                    elif t.IsValueType                                                    then make typedefof<CommonEqualityTypes.ValueType.Equality<int>>
  +
  +                    elif typeof<IStructuralEquatable>.IsAssignableFrom t                  then make typedefof<CommonEqualityTypes.RefType.StructuralEquatable<Tuple<int,int>>>
   
                       // only sealed as a derived class might inherit from IStructuralEquatable
  -                    elif t.IsSealed && equatable.IsAssignableFrom t                       then make Exemplars.refTypeEquatable
  -                    elif t.IsSealed                                                       then make Exemplars.refTypeEquality
  +                    elif t.IsSealed && equatable.IsAssignableFrom t                       then make typedefof<CommonEqualityTypes.RefType.Equatable<string>>
  +                    elif t.IsSealed                                                       then make typedefof<CommonEqualityTypes.RefType.Equality<string>>
   
                       else null
   
  
positive.code:                     match tyRelation with
                      | r when r.Equals typeof<PartialEquivalenceRelation> ->
                          match ty with
                          | t when t.Equals typeof<float>             -> typeof<Specializations.ComparerTypes.FloatPER>
                          | t when t.Equals typeof<float32>           -> typeof<Specializations.ComparerTypes.Float32PER>
                          | t when t.Equals typeof<Nullable<float>>   -> typeof<Specializations.ComparerTypes.NullableFloatPER>
                          | t when t.Equals typeof<Nullable<float32>> -> typeof<Specializations.ComparerTypes.NullableFloat32PER>
                          | _ -> null
                      | r when r.Equals typeof<EquivalenceRelation> ->
                          match ty with
                          | t when t.Equals typeof<float>             -> typeof<Specializations.ComparerTypes.FloatER>
                          | t when t.Equals typeof<float32>           -> typeof<Specializations.ComparerTypes.Float32ER>
                          | t when t.Equals typeof<Nullable<float>>   -> typeof<Specializations.ComparerTypes.NullableFloatER>
                          | t when t.Equals typeof<Nullable<float32>> -> typeof<Specializations.ComparerTypes.NullableFloat32ER>
                          | _ -> null
                      | _ -> raise (Exception "invalid logic")
  
                  let standardTypes (t:Type) : Type =
                      if   t.Equals typeof<bool>       then typeof<Specializations.ComparerTypes.Bool>
                      elif t.Equals typeof<sbyte>      then typeof<Specializations.ComparerTypes.Sbyte>
                      elif t.Equals typeof<int16>      then typeof<Specializations.ComparerTypes.Int16>
                      elif t.Equals typeof<int32>      then typeof<Specializations.ComparerTypes.Int32>
                      elif t.Equals typeof<int64>      then typeof<Specializations.ComparerTypes.Int64>
                      elif t.Equals typeof<nativeint>  then typeof<Specializations.ComparerTypes.Nativeint>
                      elif t.Equals typeof<byte>       then typeof<Specializations.ComparerTypes.Byte>
                      elif t.Equals typeof<uint16>     then typeof<Specializations.ComparerTypes.Uint16>
                      elif t.Equals typeof<uint32>     then typeof<Specializations.ComparerTypes.Uint32>
                      elif t.Equals typeof<uint64>     then typeof<Specializations.ComparerTypes.Uint64>
                      elif t.Equals typeof<unativeint> then typeof<Specializations.ComparerTypes.Unativeint>
                      elif t.Equals typeof<char>       then typeof<Specializations.ComparerTypes.Char>
                      elif t.Equals typeof<string>     then typeof<Specializations.ComparerTypes.String>
                      elif t.Equals typeof<decimal>    then typeof<Specializations.ComparerTypes.Decimal>
                      else null
  
                  let compilerGenerated tyRelation ty =
  
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,t>> 
                              elif 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>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_>>     then create typedefof<ComparerTypes.Tuple<int,int,int,int,int,int,t,t,t,t,t,t>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_>>   then create typedefof<ComparerTypes.Tuple<int,int,int,int,int,int,int,t,t,t,t,t,t,t>> 
                              elif tyDef.Equals typedefof<Tuple<_,_,_,_,_,_,_,_>> then create typedefof<ComparerTypes.Tuple<int,int,int,int,int,int,int,int,t,t,t,t,t,t,t,t>> 
                              else null
                          else null
  
  