在 F# 模板中使用编译时可派生类型

Question

在下面的代码中，我想使用一个变量的类型来实例化一个模板类，最终作为一个泛型变量传递给一个函数，但即使这种更简单的形式也不起作用：

type saveXY<'a when 'a:comparison> (x:'a,y:'a) =
    member this.X = x
    member this.Y = y
    member this.lessThan () = this.X < this.Y

[<EntryPoint>]
let main argv = 

    let x1 = 3
    let y1 = 7
    let saver1 = new saveXY<int>(x1,y1)            // Good
    printfn "%A" (saver1.lessThan())

    let x2 = 3.0
    let y2 = 7.0
    let saver2 = new saveXY<float>(x2,y2)          // Good
    printfn "%A" (saver2.lessThan())

    let saver3 = new saveXY<x2.GetType()> (x2,y2)  // No Good, see errors

    0 

但是，对于下面的saver3，我得到了（并且我找不到关于 FS1241 的信息）：

...\Program.fs(23,39): error FS0010: Unexpected symbol '(' in type arguments. Expected ',' or other token.
...\CompareProblem\Program.fs(23,39): error FS1241: Expected type argument or static argument

如果您删除 saveXY 上的模板，则 saver2 会出错，因为 saver1 会导致 saveXY 类参数被限制为整数。

我还尝试将 x 和 y 简单地声明为 obj，但这不起作用。我怀疑问题在于这根本不可能， 也就是说，如果类参数类型是通用的，则它们派生一次（从第一次使用开始）。另一方面，也许我错过了什么。

有没有办法使用基于变量的类型（在编译时可确定）作为 F# 中的类型模板参数？是否有另一种方法来创建能够处理/存储通用值的类型？

更新：根据 Lee 的建议，这是可行的，如果您将类模板化，然后使用 <_> 实例化它就可以了：

type saveXY<'a when 'a:comparison> (x:'a, y:'a) =
    member this.X = x
    member this.Y = y
    member this.lessThan () = this.X < this.Y

[<EntryPoint>]
let main argv = 

    let x1 = 3
    let y1 = 7
    let saver3 = new saveXY<_> (x1,y1)  // works, 'a is int
    printfn "%A" (saver3.lessThan())

    let x2 = 3.0
    let y2 = 7.0
    let saver3 = new saveXY<_> (x2,y2)  // works, 'a is float
    printfn "%A" (saver3.lessThan())

    System.Console.ReadKey() |> ignore  // wait for a key
    0  

但是为什么我需要模板类类型，就像我上面建议的那样？当我使用<_> 时，编译器似乎在推断类型，所以为什么我不能简单地使用（就像我对函数一样）：

type saveXY(x, y) =  // x and y are generic, no? They only require comparison, yes?
    member this.X = x
    member this.Y = y
    member this.lessThan () = this.X < this.Y

[<EntryPoint>]
let main argv = 

    let x1 = 3
    let y1 = 7
    let saver3 = new saveXY (x1,y1)  // works
    printfn "%A" (saver3.lessThan())

    let x2 = 3.0
    let y2 = 7.0
    let saver3 = new saveXY (x2,y2)  // But this FAILS with error FS0001
    printfn "%A" (saver3.lessThan())

    System.Console.ReadKey() |> ignore  // wait for a key
    0 

Answer 1

如果你只是想让编译器推断你可以使用的泛型参数的类型：

let saver3 = new saveXY<_>(x2, y2)

或

let saver3 = saveXY(x2, y2)

Answer 2

F# 没有任何内置方法来实例化具有运行时已知类型的泛型代码。你总是可以通过反射来做到这一点，但它并不经常使用——如果你使用反射来创建它，你实际上将无法对值做很多事情。

为了示例，您可以将LessThan 移动到单独的界面中：

type ILessThan = 
  abstract LessThan : unit -> bool

type SaveXY<'T when 'T:comparison> (x:'T,y:'T) =
  member this.X = x
  member this.Y = y
  interface ILessThan with 
    member this.LessThan () = 
      printfn "Comparing values of type: %s" (typeof<'T>.Name)
      this.X < this.Y

给定一个System.Type 和两个代表参数的obj 值，您可以在运行时使用反射创建SaveXY<T> 的实例，其中typeof<T> 是给定的System.Type：

let createSaveXY typ x y = 
  let typ = typedefof<SaveXY<_>>.MakeGenericType [| typ |]
  typ.GetConstructors().[0].Invoke([| x; y |]) :?> ILessThan

这是一个如何工作的示例：

let lt = createSaveXY (typeof<float>) (box 3.0) (box 7.0)
lt.LessThan()

但正如我之前所说，这很少有用，而且效率不高 - 所以与其复制这个，不如试着描述你要解决的问题 - 可能有更好的解决方案。