anchor.diff:                              
                   static member Func = _func
   
  +            let hasFSharpCompilerGeneratedEquality<'a> () =
  +                let rec tryFindObjectsInterfaceMethod (objectType:Type) (interfaceType:Type) (methodName:string) (methodArgTypes:array<Type>) =
  +                    if not (interfaceType.IsAssignableFrom objectType) then null
  +                    else
  +                        let methodInfo = interfaceType.GetMethod (methodName, methodArgTypes) 
  +                        let interfaceMap = objectType.GetInterfaceMap interfaceType
  +                        let rec findTargetMethod index =
  +                            if index = interfaceMap.InterfaceMethods.Length then null
  +                            elif methodInfo.Equals (get interfaceMap.InterfaceMethods index) then (get interfaceMap.TargetMethods index)
  +                            else findTargetMethod (index+1)
  +                        findTargetMethod 0
  +
  +                let rec isCompilerGeneratedInterfaceMethod objectType interfaceType methodName methodArgTypes =
  +                    match tryFindObjectsInterfaceMethod objectType interfaceType methodName methodArgTypes with
  +                    | null -> false
  +                    | m -> 
  +                        match m.GetCustomAttribute typeof<CompilerGeneratedAttribute> with
  +                        | null -> false
  +                        | _ -> true
  +
  +                let rec isCompilerGeneratedMethod (objectType:Type) (methodName:string) (methodArgTypes:array<Type>) =
  +                    match objectType.GetMethod (methodName, methodArgTypes) with
  +                    | null -> false
  +                    | m ->
  +                        match m.GetCustomAttribute typeof<CompilerGeneratedAttribute> with
  +                        | null -> false
  +                        | _ -> true
  +
  +                match typeof<'a>.GetCustomAttribute typeof<CompilationMappingAttribute> with
  +                | :? CompilationMappingAttribute as m when (m.SourceConstructFlags.Equals SourceConstructFlags.ObjectType(*struct*)) || (m.SourceConstructFlags.Equals SourceConstructFlags.RecordType) ->
  +                    isCompilerGeneratedInterfaceMethod typeof<'a> typeof<IEquatable<'a>> "Equals" [|typeof<'a>|]
  +                    && isCompilerGeneratedInterfaceMethod typeof<'a> typeof<IStructuralEquatable> "Equals" [|typeof<obj>; typeof<IEqualityComparer>|]
  +                    && isCompilerGeneratedMethod typeof<'a> "Equals" [|typeof<obj>|] 
  +                | _ -> false
  +
               type GenericSpecializeEqualsWithRelation<'relation, 'a>() =
                   static let generalize (func:Func<IEqualityComparer,'aa,'aa,bool>) =
                       match box func with
  
positive.code:             type private EquivalenceRelation = class end
              type private PartialEquivalenceRelation = class end
  
              type GenericSpecializeEquals_Pass1<'a>() =
                  static let generalize (func:Func<IEqualityComparer,'aa,'aa,bool>) =
                      match box func with
                      | :? Func<IEqualityComparer,'a, 'a, bool> as f -> f
  
negative.code:                     | 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
  
                      | t when t.IsValueType && typeof<IStructuralEquatable>.IsAssignableFrom t ->
                          let equals = typeof<IStructuralEquatable>.GetMethod ("GetHashCode", [|typeof<IEqualityComparer>|])
                          let ec = Expression.Parameter typeof<IEqualityComparer>
                          let a = Expression.Parameter typeof<'a>
                          let lambda = Expression.Lambda<_> (Expression.Call (a, equals, ec), ec, a)
                          lambda.Compile ()
  
                      | t when typeof<IStructuralEquatable>.IsAssignableFrom t ->
                          (Func<_,_,_>(fun ec (a:'a) ->
  