anchor.diff:  
                   let equalityInterfaces (t:Type) : obj =
                       let make = makeEquatableDelegate t t
  -
  -                    let notnull =
  -                        let id = IntrinsicFunctions.getTypeInfo t
  -                        id = IntrinsicFunctions.TypeNullnessSemantics_NullNotLiked || id = IntrinsicFunctions.TypeNullnessSemantics_NullNever
   
                       let equatable = makeEquatableType t
   
  
positive.code:                 type StructEquals<'a when 'a : struct and 'a : equality>() =
                      member __.Equals (_:IEqualityComparer, x:'a, y:'a) = x.Equals y
  
                  type RefTypeStructualEquality<'a when 'a : not struct and 'a :> IStructuralEquatable>() =
                      member __.Equals (ec:IEqualityComparer, x:'a, y:'a) = Calls.StructualEqualityEquals (ec, x, y)
  
                  type RefTypeEquatable<'a when 'a : not struct and 'a :> IEquatable<'a>>() =
                      member __.Equals (_:IEqualityComparer, x:'a, y:'a) = Calls.EquatableEquals (x, y)
  
                  type RefTypeEquals<'a when 'a : not struct and 'a : equality>() =
                      member __.Equals (_:IEqualityComparer, x:'a, y:'a) = x.Equals y
  
                  type RefTypeNullableStructualEquality<'a when 'a : not struct and 'a : null and 'a :> IStructuralEquatable>() =
                      member __.Equals (ec:IEqualityComparer, x:'a, y:'a) =
                          match x, y with
  
negative.code:                     elif t.IsValueType && equatable.IsAssignableFrom t                    then make typedefof<StructEquatable<DummyStructInterfaces>>
                      elif t.IsValueType                                                    then make typedefof<StructEquals<DummyStructInterfaces>>
  
                      elif typeof<IStructuralEquatable>.IsAssignableFrom t                  then make typedefof<RefTypeNullableStructualEquality<DummyRefTypeInterfaces>>
  
                      // only sealed as a derived class might inherit from IStructuralEquatable
                      elif t.IsSealed && equatable.IsAssignableFrom t                       then make typedefof<RefTypeNullableEquatable<DummyRefTypeInterfaces>>
                      elif t.IsSealed                                                       then make typedefof<RefTypeNullableEquals<DummyRefTypeInterfaces>>
  
                      else null
  