f# - 合理嵌套函数

Question

我创建了一个 combine 函数，给定一个列表元组，返回一个元组列表:

let rec combine =
fun (l1, l2) ->
    match (l1, l2) with
    | ([], [])          -> []
    | (x::xs, y::ys)    -> (x, y)::(combine xs ys)

然后我构建了一个类似的函数 foo56，它的工作方式相同，但有四个列表而不是两个。

let rec foo76 =     //Combine  a 4-tuple of lists in a list of 4-tuples
fun (l1, l2, l3, l4) ->
    match (l1, l2, l3, l4) with
    ([], [], [], [])                ->  []
    | (x::xs, y::ys, z::zs, t::ts)  ->
        (x, y, z, t)::(foo76 (xs, ys, zs, ts))

问题:我想实现 foo56 以使其通过 combine 工作。我做了几次尝试，都失败了。这是最(叹息)最有前途的:

let foo76combine =     //Combine  a 4-tuple of lists in a list of 4-tuples
    fun (l1, l2, l3, l4) ->
        match (l1, l2, l3, l4) with
        ([], [], [], [])                ->  []
        | (x::xs, y::ys, z::zs, t::ts)  ->
            (x, y, z, t)::(combine(combine(combine (xs, ys) zs) ts))

我无法想象如何正确地将 combine 递归地嵌套在自身中。我想这可能是由于我缺乏经验。至少我是在正确的道路上吗？它不仅仅是让 foo76 工作。我有兴趣更好地掌握这种方法的实际应用，在那里我可以将问题分解成更小的部分。

Answer 1

你不能通过简单地编写combine来得到你想要的。 .最里面combine将按预期工作，产生 ('a * 'b) list , 但下一个需要 ('a * 'b) list和一个 'c list , 产生 (('a * 'b) * 'c)) list , 而不是 ('a * 'b * 'c) list你想看到的。

元组根本不是那样工作的——你不能概括为“任意长度的元组”。这就是为什么有单独的 List.zip和 List.zip3功能，而不是一般的List.zipN .如果您想处理不同大小的元组，则需要为它们提供不同且独立的函数。

您可以通过将生成的“嵌套”元组映射到 4 元组来稍微弥补这一点，但是重用 combine 会得到什么？在我看来不值得麻烦 - 与 foo76 这样的专用函数相比，它更难阅读且性能更差:

let rec zip4 (l1, l2, l3, l4) =
    match l1, l2, l3, l4 with
    | [], [], [], []              ->  []
    | x::xs, y::ys, z::zs, t::ts  ->
        (x, y, z, t) ::
            (List.map
                (fun (((a,b),c),d) -> (a,b,c,d))
                (combine(combine(combine(xs, ys), zs), ts)))