anchor.diff:                          let make = makeCompareDelegate t underlyingType 
                           let underlyingComparableGeneric = mos.makeComparableType underlyingType
                           
  -                        if typeof<IStructuralComparable>.IsAssignableFrom underlyingType   then make Exemplars.nullableStructualComparable
  +                        if typeof<IStructuralComparable>.IsAssignableFrom underlyingType   then make Exemplars.nullableStructuralComparable
                           elif underlyingComparableGeneric.IsAssignableFrom underlyingType   then make Exemplars.nullableComparableGeneric
                           else                                                                    make Exemplars.nullableComparable
   
  -                    elif t.IsValueType && typeof<IStructuralComparable>.IsAssignableFrom t then make Exemplars.valueTypeStructualComparable
  +                    elif t.IsValueType && typeof<IStructuralComparable>.IsAssignableFrom t then make Exemplars.valueTypeStructuralComparable
                       elif t.IsValueType && comparableGeneric.IsAssignableFrom t             then make Exemplars.valueTypeComparableGeneric
                       elif t.IsValueType && typeof<IComparable>.IsAssignableFrom t           then make Exemplars.valueTypeComparable
   
  -                    elif typeof<IStructuralComparable>.IsAssignableFrom t                  then make Exemplars.refTypeStructualComparable
  +                    elif typeof<IStructuralComparable>.IsAssignableFrom t                  then make Exemplars.refTypeStructuralComparable
   
                       // only sealed as a derived class might inherit from IStructuralComparable
                       elif t.IsSealed && comparableGeneric.IsAssignableFrom t                then make Exemplars.refTypeComparableGeneric
  
positive.code:                     upcast Delegate.CreateDelegate (makeGetHashCodeReturnType ty, instance, "GetHashCode")
  
                  type Calls =
                      static member StructualEqualityGetHashCode<'a when 'a :> IStructuralEquatable> (ec, x:'a) = x.GetHashCode (ec) 
                      
                  type NullableStructualEquality<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a :> IStructuralEquatable>() =
                      member __.GetHashCode (ec:IEqualityComparer, x:Nullable<'a>) =
                          if x.HasValue then Calls.StructualEqualityGetHashCode<'a> (ec, x.Value)
                          else 0
  
                  type NullableGetHashCode<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a : equality>() =
  
negative.code: 
  #if FX_ATLEAST_40 // should probably create some compilation flag for this stuff
              module Exemplars =
                  type Calls =
                      static member StructuralEqualityEquals<'a when 'a :> IStructuralEquatable> (ec, x:'a, y:'a) = x.Equals (box y, ec) 
                      static member EquatableEquals<'a when 'a :> IEquatable<'a>> (x:'a, y:'a) = x.Equals y
  
                  module Nullable =
                      type StructuralComparable<'a when 'a : struct and 'a : (new : unit ->  'a) and 'a :> ValueType and 'a :> IStructuralComparable>() =
                          member __.CompareTo (ec:IComparer, x:Nullable<'a>, y:Nullable<'a>) =
                              match x.HasValue, y.HasValue with
                              | false, false -> 0
  