从功能上解决问题：如何使用 Haskell？

Question

我正在尝试解决 H99 中的一个问题： 将列表分成两部分；第一部分的长度已给出。

不要使用任何预定义的谓词。

例子：

> (split '(a b c d e f g h i k) 3)
( (A B C) (D E F G H I K))

我可以很快找到解决方案：

split'::[a]->Int->Int->[a]->[[a]]
split' [] _ _ _     = []
split' (x:xs) y z w = if y == z then [w,xs] else split' xs y (z+1) (w++[x])

split::[a]->Int->[[a]]
split x y = split' x y 0 []

我的问题是，我所做的只是以递归格式重写循环版本。这是你在 Haskell 中做事的正确方式吗？不就是和命令式编程一样吗？

编辑：另外，你通常如何避免这里的额外功能？

Answer 1

您通常可以将命令式解决方案转换为 Haskell，这很方便，但您是对的，您通常希望找到更自然的递归语句。特别是对于这一点，根据基本情况和归纳情况进行推理可能非常有帮助。那么你的基本情况是什么？为什么，当分割位置为0时：

split x 0 = ([], x)

可以通过将列表的第一个元素附加到用 n-1 拆分的结果上来构建归纳案例：

split (x:xs) n = (x:left, right)
  where (left, right) = split xs (n-1)

这可能表现不佳（它可能没有你想象的那么糟糕），但它说明了我第一次遇到问题并想从功能上解决问题时的思考过程。

编辑：另一个更依赖 Prelude 的解决方案可能是：

split l n = (take n l, drop n l)

Answer 2

实际上和命令式编程不一样，每个函数调用都避免了任何副作用，它们只是简单的表达式。但我对你的代码有一个建议

split :: Int -> [a] -> ([a], [a])
split p xs = go p ([], xs)
  where go 0 (xs, ys) = (reverse xs, ys)
        go n (xs, y:ys) = go (n-1) (y : xs, ys)

所以我们如何声明我们只返回两个东西 ([a], [a]) 而不是一个东西列表（这有点误导）并且我们已经将尾递归调用限制在本地范围内。

我也在使用模式匹配，这是在 Haskell 中编写递归函数的一种更惯用的方法，当 go 用零调用时，则运行第一种情况。编写向下而不是向上的递归函数通常更令人愉快，因为您可以使用模式匹配而不是 if 语句。

最后这更有效，因为++ 在第一个列表的长度上是线性的，这意味着您的函数的复杂性是二次的而不是线性的。与 Daniel 的解决方案不同，此方法也是尾递归的，这对于处理任何大型列表都很重要。

TLDR：两个版本都是函数式风格，避免变异，使用递归而不是循环。但是我提供的版本更接近 Haskell 并且速度稍快。

关于尾递归的一句话

此解决方案使用尾递归这在 Haskell 中并不总是必不可少的，但在这种情况下，当您使用结果列表时很有帮助，但在其他时候实际上是一件坏事。例如，map 不是尾递归的，但如果是，你就不能在无限列表中使用它！

在这种情况下，我们可以使用尾递归，因为整数总是有限的。但是，如果我们只使用列表的第一个元素，Daniel 的解决方案会快得多，因为它会延迟生成列表。另一方面，如果我们使用整个列表，我的解决方案会快得多。

Answer 3

split'::[a]->Int->([a],[a])

split' [] _ = ([],[])
split' xs 0 = ([],xs)
split' (x:xs) n = (x:(fst splitResult),snd splitResult) 
                  where splitResult = split' xs (n-1)

看来你已经展示了一个更好的解决方案的例子。

我建议您阅读SICP。然后你得出的结论是额外的功能是正常的。还有广泛使用的方法来隐藏局部区域的功能。这本书对你来说可能看起来很无聊，但在前面几章中，她会习惯于用函数式方法解决问题。

有些任务更需要递归方法。但是例如，如果您使用尾递归（经常被无缘无故地称赞），那么您会注意到这只是通常的迭代。通常带有隐藏迭代变量的“额外功能”（哦..单词变量不是很合适，可能是参数）。