1

阅读本文unfoldr时，我发现了使用函数生成斐波那契数列的示例：

fibs = unfoldr (\(a,b) -> Just (a,(b,a+b))) (0,1)

但是当我查看文档时，我发现unfoldr函数中的 lambda 只需要一个参数b：

unfoldr :: (b -> Maybe (a, b)) -> b -> [a]

文档中的示例也仅演示了一种参数用法：

unfoldr (\b -> if b == 0 then Nothing else Just (b, b-1)) 10

所以，我很感兴趣如何将它应用于斐波那契示例中的两个参数？

4

2 回答 2

6

这是你的功能：

GHCi> let foo = \(a,b) -> Just(a,(b,a+b))

虽然我们当然可以在脑海中将它解释为两个参数的函数，但就 Haskell 而言，它只需要一个参数......

foo :: Num t => (t, t) -> Maybe (t, (t, t))

...类中某些人的一对类型。那么，在您的示例中发生的所有事情就是in的签名被替换为和，从而导致：(t, t)tNumbunfoldrNum t => (t, t)aNum t => t

Num t => ((t, t) -> Maybe (t, (t, t))) -> (t, t) -> [t]

一些额外的证据：

GHCi> :t unfoldr (\(a,b) -> Just (a,(b,a+b)))
unfoldr (\(a,b) -> Just (a,(b,a+b))) :: Num a => (a, a) -> [a]

回答您的直接问题后，这里有一点题外话。将两个参数传递给 Haskell 函数的另一种方法是将它们分开传递，而不是成对传递：

GHCi> let foo2 a b = Just(a,(b,a+b))
GHCi> :t foo2
foo2 :: Num t => t -> t -> Maybe (t, (t, t))

显然，如果你仍然有foo你甚至不需要重写实现：

GHCi> let foo2 a b = foo (a, b)
GHCi> :t foo2
foo2 :: Num t => t -> t -> Maybe (t, (t, t))

事实上，这种转换——在行话中被称为柯里化——总是可能的，甚至还有一个函数可以做到这一点……

GHCi> let foo2 = curry foo
GHCi> :t foo2
foo2 :: Num t => t -> t -> Maybe (t, (t, t))

...以及另一个相反的方向：

GHCi> :t uncurry foo2
uncurry foo2 :: Num t => (t, t) -> Maybe (t, (t, t))

然而，所有这一切可能令人惊讶的是 even foo2，它看起来更像是两个参数的函数，而不是foo，仍然是一个参数的函数！诀窍是像foo2...这样的签名

foo2 :: Num t => t -> t -> Maybe (t, (t, t))

... 有一些省略的可选括号。->省略隐藏了函数箭头, 是右结合的事实。如果我们添加它们，我们会得到：

foo2 :: Num t => t -> (t -> Maybe (t, (t, t)))

也就是说，foo2接受一个参数（即我们的第一个参数）并返回另一个函数，该函数也接受一个参数（即我们的第二个参数）。

那么，主要的收获是所有的 Haskell 函数都只接受一个参数。幸运的是，编写像接受两个参数一样工作的函数非常容易。通常情况下，这是通过以柯里化方式编写函数来完成的（即，作为这样的函数foo2返回另一个函数），但有时需要或方便成对传递多个值，就像你必须做的那样在你的例子中。

于 2016-10-22T01:08:40.413 回答
-1

首先，unforldr 应用于 func ((a,b) -> Just (a, (b, a+b)))

返回一个函数 b -> [a]。这是一个咖喱。

然后将结果函数应用于第二个参数 (0, 1)

这结束了最终结果。

于 2016-10-22T00:37:21.307 回答