将 F# 函数参数限制为通用接口的多个实例失败并显示 FS0193

Question

我试图限制f＃函数参数以符合多个接口，而多个接口又从相同的通用接口声明中得出：

module GenericInterfaceTest =

  (* declare an interface using generic type *)
  type IReader<'a> =
    abstract member readValue : 'a

  (* constraining only int works *)
  let useReaderInt<'r when 'r :> IReader<int>> (reader : 'r) =
    (reader :> IReader<int>).readValue

  (* constraining only float works *)
  let useReaderFloat<'r when 'r :> IReader<float>> (reader : 'r) =
    (reader :> IReader<float>).readValue

  (* [FS0193] Type constraint mismatch.
     The type ''r' is not compatible with type 'IReader<float>' *)
  let useReaders<'r when 'r :> IReader<int> and 'r :> IReader<float>> (reader : 'r) =
    (reader :> IReader<int>).readValue, (reader :> IReader<float>).readValue

  (* [FS0193] Type constraint mismatch.
     The type ''r' is not compatible with type 'IReader<int>' *)
  let useReaders<'r when 'r :> IReader<float> and 'r :> IReader<int>> (reader : 'r) =
    (reader :> IReader<int>).readValue, (reader :> IReader<float>).readValue


  (* ------------------------------------------------------------------------
     Not using generic type works
     ------------------------------------------------------------------------ *)
  type IIntReader =
    abstract member readValue : int

  type IFloatReader =
    abstract member readValue : float

  (* works *)
  let useReaders<'r when 'r :> IIntReader and 'r :> IFloatReader> (reader : 'r) =
    (reader :> IIntReader).readValue, (reader :> IFloatReader).readValue


  (* ------------------------------------------------------------------------
     Using different generic declarations works
     ------------------------------------------------------------------------ *)
  type IReader2<'a> =
    abstract member readValue : 'a

  (* works *)
  let useReaders<'r when 'r :> IReader<int> and 'r :> IReader2<float>> (reader : 'r) =
    (reader :> IReader<int>).readValue, (reader :> IReader2<float>).readValue


  (* ------------------------------------------------------------------------
     Using type aliases does not work
     ------------------------------------------------------------------------ *)
  type IReaderInt = IReader<int>
  type IReaderFloat = IReader<float>

  (* [FS0193] Type constraint mismatch.
     The type ''r' is not compatible with type 'IReaderInt' *)
  let useReaders<'r when 'r :> IReaderFloat and 'r :> IReaderInt> (reader : 'r) =
    (reader :> IReader<int>).readValue, (reader :> IReader2<float>).readValue

这是编译器错误还是限制，还是我做错了什么？

是否有另一种方法可以实现此目的，而不必使用具体类型多次编写代码？

编辑：我在 https://github.com/fsharp/fsharp/fsharp/fsharp/fslang-suggestions/issues/issues/1036

这是一个涉及类型推理的限制。

其中一条评论通过具有中间的非生成界面继承通用专业知识来提及围绕此问题。如果有人能帮助我以一个如何做这件事的示例，我将非常感激 - 我最好的猜测是不起作用的：

module GenericInterfaceTest2 =
  (* declare an interface using generic type *)
  type IReader<'a> =
    abstract member readValue : 'a

  type IReaderInt = inherit IReader<int>

  type IReaderFloat = inherit IReader<float>

  (* works *)
  let useReaders<'r when 'r :> IReaderInt> (reader : 'r) =
    (reader :> IReader<int>).readValue

  (* [FS0193] Type constraint mismatch.
     The type ''r' is not compatible with type 'IReaderFloat' *)
  let useReaders<'r when 'r :> IReaderInt and 'r :> IReaderFloat> (reader : 'r) =
    (reader :> IReaderInt).readValue, (reader :> IReaderFloat).readValue

Answer 1

这并不漂亮，但它可以编译：

type IReaderIntFloat =
    inherit IReader<int>
    inherit IReader<float>

let useReaders (reader : IReaderIntFloat) =
    (reader :> IReader<int>).readValue, (reader :> IReader<float>).readValue

Answer 2

您可以使用非泛型包装类型和灵活类型：

// Input type
type IReader<'a> =
    abstract member readValue : 'a

// Wrapper types
type IReaderInt =
    abstract readInt : int

type IReaderFloat =
    abstract readFloat : float

// Implementation
type NumberReader(intReader: IReader<int>, floatReader: IReader<float>) =
    interface IReaderInt with
        member _.readInt = intReader.readValue

    interface IReaderFloat with
        member _.readFloat = floatReader.readValue

// Helpers
let readInt (reader: #IReaderInt) =
    reader.readInt

let readFloat (reader: #IReaderFloat) =
    reader.readFloat

// Final function
let readNumbers reader =
    readInt reader, readFloat reader
// val readNumbers:
//  reader: 'a -> int * float when 'a :> IReaderInt and 'a :> IReaderFloat

首先，我尝试使用继承，但类型推断不再起作用

Answer 3

谢谢 Romain，你让我走上了以下道路：

(* Input type *)
type IReader<'a> =
    abstract member readValueTupled : unit -> 'a * 'a
    abstract member readValue : unit -> 'a

(* generic implementation *)
type GenericImplementation<'a> (a : 'a) =
    interface IReader<'a> with
      member this.readValueTupled () = (a, a)
      member this.readValue () = a

module Int =
  (* Wrapper types *)
  type IReader =
      abstract member readValueTupled : unit -> int * int
      abstract member readValue : unit -> int

module Float =
  (* Wrapper types *)
  type IReader =
      abstract member readValue : unit -> float
      abstract member readValueTupled : unit -> float * float

(* Implementation of class, using the generic implementation above *)
type NumberReader(anInt : int, aFloat : float) =
  let IReaderInt = (GenericImplementation(anInt) :> IReader<int>)
  let IReaderFloat = (GenericImplementation(aFloat) :> IReader<float>)

  interface Int.IReader with
    member _.readValueTupled () = IReaderInt.readValueTupled ()
    member _.readValue () = IReaderInt.readValue ()

  interface Float.IReader with
    member _.readValueTupled () = IReaderFloat.readValueTupled ()
    member _.readValue () = IReaderInt.readValue ()

(* Final function *)
(* val reader: 'a (requires 'a :> Int.IReader and 'a :> Float.IReader) *)
let readNumbers reader =
    (reader :> Int.IReader).readValueTupled ()
    , (reader :> Float.IReader).readValue ()

这将允许我定义一个接口并通用地编写实现，然后将不同的实例传递到尊重接口隔离的函数中。

我添加了第二个成员来测试重构，发现在正确的位置进行正确的更改很痛苦。

因此，我已经接受了，而不是在调用站点传递一组所需的读者，这意味着我可以做这样的事情：

  (* Input type *)
  type IReader<'a> =
      abstract member readValueTupled : unit -> 'a * 'a
      abstract member readValue : unit -> 'a
  
  (* generic implementation - do something *)
  type Reader<'a> (a : 'a) =
      interface IReader<'a> with
        member this.readValueTupled () = (a, a)
        member this.readValue () = a
  
  (* Implementation of class, using the generic implementation above *)
  type NumberReaderAndOtherThings(anInt : int, aFloat : float) =
    member _.IReaderInt = Reader<int>(anInt) :> IReader<int>
    member _.IReaderFloat = Reader<float>(aFloat) :> IReader<float>    
  
  
  (* Called function *)
  let useReaders (readerInt : IReader<int>, readerFloat : IReader<float>) =
      readerInt.readValueTupled (), readerFloat.readValueTupled ()

  (* Call site *)
  let useAllThis = 
    let myClass = NumberReaderAndOtherThings(1, 1.1)
    useReaders (myClass.IReaderInt, myClass.IReaderFloat)

在我的例子中，目前只有通用实现，所以我意识到我可以省去完全界面（目前）：

(* generic implementation - do something *)
type Reader<'a> (a : 'a) =
  member this.readValueTupled () = (a, a)
  member this.readValue () = a

(* Implementation of class, using the generic implementation above *)
type NumberReaderAndOtherThings(anInt : int, aFloat : float) =
  member _.IReaderInt = Reader<int>(anInt)
  member _.IReaderFloat = Reader<float>(aFloat)

(* Called function *)
let useReaders (readerInt : Reader<int>, readerFloat : Reader<float>) =
    readerInt.readValueTupled (), readerFloat.readValueTupled ()

(* Call site *)
let useAllThis =
  let myClass = NumberReaderAndOtherThings(1, 1.1)
  useReaders (myClass.IReaderInt, myClass.IReaderFloat)

谢谢大家的帮助，很抱歉这篇文章很长，也许它对将来的人有帮助（欢迎所有建议和评论）。