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

简答

您要查找的功能已作为List.unzip3.

存在于FSharp.Core中

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来保留原始列表顺序。

多类型列表

1 个答案: