F# 元组类型的模式匹配

Question

我有一个柯里化函数，我希望它支持不同类型的参数，这些参数不属于继承关系：

type MyType1 = A | B of float
type MyType2 = C | D of int

我试图做的是：

let func x y =
    match (x, y) with
    | :? Tuple<MyType1, MyType1> -> "1, 1"
    | _ -> "..."

但是这是不可能的。 F# 抱怨：

类型 ''a * 'b' 没有任何适当的子类型，不能用作类型测试或运行时强制的源。

执行此操作的优雅方法是什么？

编辑：让我尝试澄清这一点。

我有两种相似但不同的类型。我可以非常轻松地将一种类型转换为另一种类型。我想定义一个将作用于这些类型的实体的二元操作，但我想向客户端公开单个操作。

也就是说，不是提供：

let op11 (x : MyType1) (y : MyType1) = // do something useful
let op12 (x : MyType1) (y : MyType2) =
    // convert y to MyType1
    let y' = // ...
    // dispatch to op11
    op11 x y'
let op21 (x : MyType2) (y : MyType1) = // similar
let op22 (x : MyType2) (y : MyType2) = // similar

我想要的是向客户端代码公开单个函数：

let op (x : obj) (y : obj) = // ...

这就像模拟方法重载的行为，但使用柯里化函数。

Answer 1

您的代码不起作用，因为 F# 将参数类型概括为类型参数。我认为您无法动态测试类型 'a * 'b 是否可以转换为类型 MyType1 * MyType2 （尽管这对我来说有点令人困惑）。在任何情况下，您都可以编写一个函数，该函数接受两个 obj 类型的参数，并使用两个 :? 模式分别测试它们：

type MyType1 = A | B of float 
type MyType2 = C | D of int

let func (x:obj) (y:obj) = 
    match (x, y) with 
    | (:? MyType1 as x1), (:? MyType1 as x2) -> 
        printfn "%A %A" x1 x2
    | _ -> 
        printfn "something else" 

func A (B 3.0) // A B 3.0
func A (D 42)  // something else

无论如何，知道为什么这样做会很有趣你想这样做吗？可能有更好的解决方案...

编辑 (2) 因此，从 T1 和 T2 的所有 4 个二元素组合中，您想要可以采用 3 的函数。正确吗（T1 * T1、T1 * T2 和 T2 * T2）？在这种情况下，您无法编写完全安全的柯里化函数，因为第二个参数的类型将“依赖于”第一个参数的类型（如果第一个参数的类型为 T2，则第二个参数也必须是 T2 （否则也可以是 T1））。

您可以编写一个安全的非柯里化函数，该函数采用以下类型的参数：

type MyArg = Comb1 of T1 * T1 | Comb2 of T1 * T2 | Comb3 of T2 * T2

该函数的类型为 MyArg ->字符串。
如果您想要一个柯里化函数，您可以定义一个类型，允许您使用 T1 或 T2 作为第一个和第二个参数。

type MyArg = First of T1 | Second of T2

然后，你的柯里化函数将是 MyArg ->我的Arg ->字符串。但请注意，如果不允许使用一种参数类型组合（如果我理解正确，则不应允许使用 T2 * T1）。在这种情况下，您的函数只需抛出异常或类似的东西。

Answer 2

本质上有三种不同的方法可以实现这一点。

第一个是按照您的建议通过向上转换为 obj 来牺牲静态类型：

let func x y =
  match box x, box y with
  | (:? MyType1 as x), (:? MyType1 as y) ->
      ...

这实际上总是一个糟糕的解决方案，因为它会导致引入不必要的运行时类型检查：

  | _ -> invalidArg "x" "Run-time type error"

唯一 我看到这个工作很好的地方是专门为用户从 F# 交互式会话中调用而设计的库代码，其中编译时和运行时类型错误实际上同时发生，并且动态类型可以更简洁。例如，我们的 F# for Visualization 库允许用户尝试可视化任何值使用此技术为不同（已知）类型调用自定义可视化例程的任何类型（了解更多）。

第二种是将两种单独的类型替换为单一类型：

type MyType1 = A | B of float | C | D of int   

第三种解决方案是引入一种新类型来统一这两种类型：

type MyType = MyType1 of MyType1 | MyType2 of MyType2

Answer 3

我有两个相似但不同的，
类型。我可以很容易地转换一个
键入另一个。我想定义一个
将作用于的二元运算
这些类型的实体，但我想
将单个操作暴露给
客户端。

这个函数应该决定哪一个
要调用的 opXY，正确向下转型
类型。

这是其中正确答案不是“这就是你如何做”，而是“不要那样做”的情况之一。如果您不打算坚持使用 F# 的习惯用法和类型检查器，那么使用 F# 就没有真正的优势。

从我的角度来看，如果您的类型非常相似，那么它们应该合并为同一类型：

type MyType = A | B of float | C | D of int

除此之外，您可以将两种类型包装在另一种类型中：

type composite =
    | MyType1Tuple of MyType1 * MyType1
    | MyType2Tuple of MyType2 * MyType2

另一层间接永远不会伤害任何人。但至少现在您的客户可以用另一个对象包装对象而不会失去类型安全性。

除此之外，请为不同类型公开两个单独的方法。

Answer 4

这闻起来很可疑，你应该描述更大的问题背景，因为看起来你不应该处于这种情况。那是说：

type MyType1 = A | B of float 
type MyType2 = C | D of int 

// imagine this adds floats, and C -> A (=0.0) and D -> B
let DoIt x y =
    match x, y with
    | A, A -> 0.0
    | A, B z -> z
    | B z, A -> z
    | B z1, B z2 -> z1 + z2

let Convert x =
    match x with
    | C -> A
    | D i -> B (float i)

let Func (x:obj) (y:obj) =
    match x, y with
    | (:? MyType2 as xx), (:? MyType2 as yy) -> DoIt (Convert xx) (Convert yy)
    | (:? MyType1 as xx), (:? MyType2 as yy) -> DoIt xx (Convert yy)    
    | (:? MyType2 as xx), (:? MyType1 as yy) -> DoIt (Convert xx) yy
    | (:? MyType1 as xx), (:? MyType1 as yy) -> DoIt xx yy    
    | _ -> failwith "bad args"