anchor.diff:                          | null -> raise (Exception "invalid logic")
                           | :? GenericSpecializeEqualsOther as t ->
                               match t with
  +#if FX_ATLEAST_40
  +#else
                               | GenericSpecializeEqualsOther.ReferenceTypeStructuralEquality ->
                                   upcast Func<IEqualityComparer,'a,'a,bool>(fun ec a b ->
                                       match box a, box b with
  
positive.code:                 type StructEquals<'a when 'a : struct and 'a : equality>() =
                      member __.Equals (_:IEqualityComparer, x:'a, y:'a) = x.Equals y
  
                  [<Struct; NoComparison; CustomEquality>]
                  type DummyWithInterfaces =
                      interface IStructuralEquatable with
                          member __.Equals (_,_) = raise (Exception "invalid logic")
                          member __.GetHashCode _ = raise (Exception "invalid logic")
  
                      interface IEquatable<DummyWithInterfaces> with
                          member __.Equals _ = raise (Exception "invalid logic")
  #endif
                  let equalityInterfaces (ty:Type) : obj =
                      let make = makeEquatableDelegate ty
  
                      match ty with
                      | t when t.IsArray || typeof<System.Array>.IsAssignableFrom t ->
                          // I could do something here, but I doubt it would have any real performance impact
                          null
  
  #if FX_ATLEAST_40
                      | t when t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t -> make typedefof<StructStructualEquality<DummyWithInterfaces>>
                      | t when t.IsValueType && (makeEquatableType ty).IsAssignableFrom t       -> make typedefof<StructEquatable<DummyWithInterfaces>>
                      | t when t.IsValueType                                                    -> make typedefof<StructEquals<DummyWithInterfaces>>
  
                      | t when typeof<IStructuralEquatable>.IsAssignableFrom t ->
                          box GenericSpecializeEqualsOther.ReferenceTypeStructuralEquality
  #else
                      | t when t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t ->
                          let equals = typeof<IStructuralEquatable>.GetMethod ("Equals", [|typeof<obj>; typeof<IEqualityComparer>|])
  
negative.code:             type private PartialEquivalenceRelation = class end
  
              type GenericSpecializeEqualsOther =
  #if FX_ATLEAST_40
  #else
              | ReferenceTypeStructuralEquality   = 0
  #endif
              | GenericEqualityObj_ER             = 2 
              | GenericEqualityObj_PER            = 3
  
  