anchor.diff:      abstract GetIt: 'a -> 'a
   
   type implementation () =
  -    interface IInterface<bool>       with member _.GetIt(x) = x
  -    interface IInterface<byte>       with member _.GetIt(x) = x
  -    interface IInterface<byte[]>     with member _.GetIt(x) = x
  -    interface IInterface<sbyte>      with member _.GetIt(x) = x
  -    interface IInterface<int16>      with member _.GetIt(x) = x
  -    interface IInterface<uint16>     with member _.GetIt(x) = x
  -    interface IInterface<int>        with member _.GetIt(x) = x
  -    interface IInterface<uint32>     with member _.GetIt(x) = x
  -    interface IInterface<int64>      with member _.GetIt(x) = x
  -    interface IInterface<uint64>     with member _.GetIt(x) = x
  -    interface IInterface<nativeint>  with member _.GetIt(x) = x
  -    interface IInterface<unativeint> with member _.GetIt(x) = x
  -    interface IInterface<char>       with member _.GetIt(x) = x
  -    interface IInterface<string>     with member _.GetIt(x) = x
  -    interface IInterface<single>     with member _.GetIt(x) = x
  -    interface IInterface<double>     with member _.GetIt(x) = x
  -    interface IInterface<decimal>    with member _.GetIt(x) = x
  -    interface IInterface<bigint>     with member _.GetIt(x) = x
  -    interface IInterface<AnEnum>     with member _.GetIt(x) = x
  +    interface IInterface<bool>                      with member _.GetIt(x) = x              // bool
  +    interface IInterface<byte>                      with member _.GetIt(x) = x              // byte
  +    interface IInterface<byte[]>                    with member _.GetIt(x) = x              // byte array
  +    interface IInterface<sbyte>                     with member _.GetIt(x) = x              // sbyte
  +    interface IInterface<int16>                     with member _.GetIt(x) = x              // int 16
  +    interface IInterface<uint16>                    with member _.GetIt(x) = x              // uint16
  +    interface IInterface<int>                       with member _.GetIt(x) = x              // int
  +    interface IInterface<uint32>                    with member _.GetIt(x) = x              // uint32
  +    interface IInterface<int64>                     with member _.GetIt(x) = x              // int64
  +    interface IInterface<uint64>                    with member _.GetIt(x) = x              // uint64
  +    interface IInterface<nativeint>                 with member _.GetIt(x) = x              // nativeint
  +    interface IInterface<unativeint>                with member _.GetIt(x) = x              // unativeint
  +    interface IInterface<char>                      with member _.GetIt(x) = x              // char
  +    interface IInterface<string>                    with member _.GetIt(x) = x              // string
  +    interface IInterface<single>                    with member _.GetIt(x) = x              // single
  +    interface IInterface<double>                    with member _.GetIt(x) = x              // double
  +    interface IInterface<decimal>                   with member _.GetIt(x) = x              // decimal
  +    interface IInterface<bigint>                    with member _.GetIt(x) = x              // bigint
  +    interface IInterface<struct (int * int)>        with member _.GetIt(x) = x              // struct tuple
  +    interface IInterface<AnEnum>                    with member _.GetIt(x) = x              // enum
  +    interface IInterface<ValueOption<string>>       with member _.GetIt(x) = x              // struct union
  +    interface IInterface<AStructRecord>             with member _.GetIt(x) = x              // struct record
  +#if !NO_ANONYMOUS        // Anonymous records are non-deterministic So don't include for il comparison
  +    interface IInterface<struct {|First:int;  Second:int|}>   with member _.GetIt(x) = x    // Anonymous record
  +#endif
  +    interface IInterface<int -> int>                with member _.GetIt(x) = x              // func
  +    interface IInterface<float -> float>            with member _.GetIt(x) = x              // func
   
   let x = implementation ()
   let assertion v assertIt =
       if not (assertIt(v)) then
           raise (new Exception (sprintf "Failed to retrieve %A from implementation" v))
   
  +let assertionRecord v assertIt =
  +    if not (assertIt(v)) then
  +        raise (new Exception (sprintf "Failed to retrieve %A from implementation" v))
  +
   // Ensure we can invoke the method and get the value back for each native F# type
  -
   assertion true (fun v -> (x :> IInterface<bool>).GetIt(v) = v)
   assertion 1uy  (fun v -> (x :> IInterface<byte>).GetIt(v) = v)
   assertion 2y   (fun v -> (x :> IInterface<sbyte>).GetIt(v) = v)
  
positive.code: assertion 'a'B (fun v -> (x :> IInterface<byte>).GetIt(v) = v)
  assertion "16"B  (fun v -> (x :> IInterface<byte[]>).GetIt(v) = v)
  assertion AnEnum.Two (fun v -> (x :> IInterface<AnEnum>).GetIt(v) = v)
  """
  
      [<Test>]
      let MultipleTypedInterfacesFSharp50() =
          CompilerAssert.PassWithOptions
              [| "--langversion:preview" |]
              multiTypedInterfaceSource
  
      [<Test>]
      let MultipleTypedInterfacesFSharp47() =
          CompilerAssert.TypeCheckWithErrorsAndOptions
              [| "--langversion:4.7" |]
              multiTypedInterfaceSource
              [|
                  (FSharpErrorSeverity.Error, 443, (15,6,15,20), "This type implements the same interface at different generic instantiations 'IInterface<AnEnum>' and 'IInterface<bigint>'. This is not permitted in this version of F#.")
              |]
  
  
negative.code: exit 0
              """
  
      let ``Many Instantiations of the same interface`` = """
  module Program
  
  open System
  
  type AnEnum =
      | One
      | Two
  
  [<Struct>]
  type AStructRecord = { Forename:string;  Surname:string }
  
  type AClass =
      val value: int
  