F# 递归类型 : method vs function type inference differences

Question

有人能解释一下为什么在 F# 中类型推断在类方法和函数之间的工作方式不同(或者我不明白的其他方面吗？)。

想象以下(简化):

type Node<'T> = Node2 of 'T * 'T
type Digit<'T> = One of 'T | Two of 'T * 'T
type Tree<'T> =
    | Empty
    | Single of 'T
    | Deep of prefix : Digit<'T> * deeper : Tree<Node<'T>>
    with
    static member Add (value : 'T) (tree : Tree<'T>) : Tree<'T> =
        match tree with
        | Empty -> Single value
        | Single a -> Deep (One value, Empty)
        | Deep (One a, deeper) -> Deep (Two (value, a), deeper)
        | Deep (Two (b, a), deeper) -> Deep (One value, deeper |> Tree.Add (Node2 (b, a)))

let rec add (value : 'T) (tree : Tree<'T>) : Tree<'T> =
    match tree with
    | Empty -> Single value
    | Single a -> Deep (One value, Empty)
    | Deep (One a, deeper) -> Deep (Two (value, a), deeper)
    | Deep (Two (b, a), deeper) -> Deep (One value, deeper |> add (Node2 (b, a)))

请注意，静态方法 Add 和函数 add 具有相同的实现，并且都以递归方式调用自身。

前者编译正常，后者报错:

Type mismatch. Expecting a
    Tree<Node<'T>> -> Tree<Node<'T>>    
but given a
    Tree<'T> -> Tree<'T>    
The resulting type would be infinite when unifying ''T' and 'Node<'T>'

Answer 1

自由 float 功能中add , 泛型类型参数属于函数本身 ( add<'T> )。

然而，在静态成员函数中，类型参数实际上属于类(Tree<'T>)。

为什么这很重要？因为当你引用函数本身时，除非另有说明，否则编译器会假定类型参数不变。它不会猜测不同的错误，因为这可能会隐藏大量类型不匹配错误。

但是，它并没有对函数所属的类型做出相同的假设。

如果检查参数，调用 add假定是对 add<'T> 的调用，这会导致无限泛型递归并且无法编译。

但是，调用Tree.Add被推断为对 Tree<Node<'T>>.Add 的调用, 不到Tree<'T>.Add .这是完全不同的函数调用。

如果您显式注释类型:

static member Add (value : 'T) (tree : Tree<'T>) : Tree<'T> =
    // ...
    | Deep (Two (b, a), deeper) -> Deep (One value, deeper |> Tree<'T>.Add (Node2 (b, a)))

您将得到与自由函数完全相同的类型不匹配/无限类型错误。

同样，如果将其设为实例成员并引用同一实例，则会出现错误:

member this.Add (value : 'T) (tree : Tree<'T>) : Tree<'T> =
    // ...
    | Deep (Two (b, a), deeper) -> Deep (One value, deeper |> this.Add (Node2 (b, a)))

反之亦然，您可以通过注释类型参数使自由函数编译，这样编译器就不会假定“它是相同的符号，因此必须引用相同的值”:

let rec add<'T> (value : 'T) (tree : Tree<'T>) : Tree<'T> =
    // ...
    | Deep (Two (b, a), deeper) -> Deep (One value, deeper |> add (Node2 (b, a)))