多类型列表

Question

我构建了一个函数，给定一个组合列表，返回两个列表：

let rec split2 l =
    match l with 
    [] -> ([], [])
    | (x, y)::ls -> let (xs, ys) =
                                split ls in (x::xs, y::ys);;  

val split2 : l:('a * 'b) list -> 'a list * 'b list

lsts = [('a', 1); ('b', 2); ('c', 3); ('d', 4)]

split2 lsts;;
val it : int list * char list = ([1; 2; 3; 4], ['a'; 'b'; 'c'; 'd'])

现在，我将这个概念应用于更复杂的列表：

let l1 = [('a', 1, 'a'); ('b', 2, 'b'); ('c', 3, 'c'); ('d', 4, 'd')]

我使用的函数出现了类型问题，所以我构建了第二个。在这种情况下，我已经仔细定义了类型，但是当它应用于l1 时仍然返回错误，即使它编译。

let rec split3 (l:(char * int * char) list) =                  
    match l with 
    [] -> ([], [], [])
    | (x, y, z)::ls -> 
                    let (xs, ys, zs) = 
                                    split3 ls in (xs, ys, zs);; 

val split3 : l:(char * int * char) list -> 'a list * 'b list * 'c list

split3 l1;;

    error FS0030: Value restriction. The value 'it' has been inferred to 
    have generic type val it : '_a list * '_b list * '_c list    
    Either define 'it' as a simple data term, make it a function with explicit 
arguments or, if you do not intend for it to be generic, add a type annotation.

为什么，即使声明了类型，也需要进一步的类型注释？

Answer 1

简答

您要查找的函数已在FSharp.Core 中作为List.unzip3. 存在

List.unzip3 : ('T1 * 'T2 * 'T3) list -> 'T1 list * 'T2 list * 'T3 list

长答案

您描述的两个函数是不同的。注意split3函数的类型签名是：

val split3 : l:(char * int * char) list -> 'a list * 'b list * 'c list

这没有意义。类型签名应该是：

val split3 : l:(char * int * char) list -> char list * int list * char list

那么，为什么不是呢？

请注意，在split2 函数中，您将结果定义为(x::xs, y::ys)，在split3 中，您将结果定义为(xs, ys, zs)。这意味着您的 split3 函数的结果始终为 ([], [], []) 但未定义空列表的类型 - 因此出现值限制错误。

这很容易解决：

let rec split3 (l:(char * int * char) list) =                  
    match l with 
    | [] -> ([], [], [])
    | (x, y, z)::ls -> 
        let (xs, ys, zs) = split3 ls
        (x::xs, y::ys, z::zs)

纠正此问题后，您可以删除类型注释，因为现在可以正确推断函数的类型：

let rec split3 l =                  
    match l with 
    | [] -> ([], [], [])
    | (x, y, z)::ls -> 
        let (xs, ys, zs) = split3 ls
        (x::xs, y::ys, z::zs)

---

此外，这种类型的函数只是一个fold，所以如果你要手动编写它，最好按照那个高阶函数来编写它，而不是通过显式递归。

let split3 l =
    let folder (x, y, z) (xs, ys, zs) =
        (x::xs, y::ys, z::zs)
    List.foldBack folder l ([], [], [])

请注意，我使用 foldBack 而不是 fold 来保留原始列表顺序。