具有函数参数的函数是否可用？

Question

从https://stackoverflow.com/a/57020455/156458

在哈斯克尔（Haskell），碰巧一切都是咖喱 。 所有函数都只使用一个参数 （即使Haskell中未使用的函数也使用一个元组，严格来说，这是一个参数-您可能需要使用curry和uncurry函数来查看其工作原理）。

我不确定这是否是正确的，但可以这样假设。

如果一个函数采用另一个函数作为参数，它的咖喱化或不咖喱化与采用不带元组或列表参数的函数类似？ （一对元组类型是type1 x type2 ，可以是type1^2 ，而函数类型是type2^{type1} ，所以我发现它们相似）

如果是未咖喱的，如何将这样的功能转换为咖喱的功能？

Answer 1

如果一个函数采用另一个函数作为参数，它是咖喱的还是不咖喱的？

它只需要一个函数，所以只需要一个参数，因此可以使用。 该参数是函数的事实是无关紧要的。

这样的功能例如是map 。 map类型：

map :: (a -> b) -> ([a] -> [b])

因此，只有一个参数，函数（类型的a -> b ），然后返回一个函数[a] -> [b]将映射的列表a s到的列表b通过应用函数s。

因此map show :: Show a => [a] -> [String]是此类函数应用程序的结果，而这又是一个函数。

Answer 2

是的，报价正确。 关于“ curried”和“ uncurried” 功能的所有说法都不准确。

哈斯克尔是一种礼貌的语言 。 Haskell中的函数始终具有指数类型。 如果参数是一个元组，那么没关系，它仍然仅仅是一个值（恰好是一个元组）。

one. 当我们将(a,b) -> c Haskell函数视为一时(a,b) -> c这些概念是近似的。 但这只是我们的精神体操。

真正需要或不需要的是编程语言 。 例如，在Lisp中，

(lambda (a b) c)

and to turn it into the function we need to put it through some transformations. 实际上具有类型并将其转换为函数，我们需要对其进行一些转换。

在Haskell中实际上没有(\\ab -> c) lambda，只有(\\ a -> (\\ b -> c))嵌套lambdas ^（ * ^） 。 当我们在Haskell中编写(\\ab -> c)时，它只是(\\ a -> (\\ b -> c))的语法快捷方式。 在Haskell中不可能有实际的(\\ab -> c) lambda函数，尽管可以通过具有(\\(a,b) -> c) lambda函数来近似。

如果您使用lambda函数实现自己的语言，那么您真正会看到所有这些含义的地方。

面对((lambda (ab) c) xyz)函数调用，真正的问题是如何配对函数的参数和提供的值 。

Haskell将其转换为((let a=x in (let b=y in c)) z) ，但是Lisp实际上将参数列表(ab)与值列表(xyz)配对，并报告长度不匹配。

但是，由于Lisp本身就是未经编程的语言 ，因此能够在这里进行各种曲折和调整，例如可选参数，默认参数，命名参数等，以各种不同的方式将参数和值配对-与Haskell不同，它总是 一次将一个参数与一个提供的值配对。

---

^（ * ^）和另一个重要区别：Haskell的(\\ a -> (\\ b -> c))中的a和b不是变量，而是模式 。 不仅像Lisp中那样为它们分配值，还与它们匹配 。

Answer 3

至少我能看到的事实是，haskell中的几乎每个值都可以看作是具有的函数，并且每个函数当时仅采用一个参数。 让我们看一个例子（以Int为例，更清楚）：

f :: Int -> Int -> Int -> Int
f x y z = x + y + z

f可以看作是接受一个Int并返回一个函数的函数

Int -> (Int -> Int)


:t (f 2)
(f 2) :: Int -> Int -> Int
:t (f 2 3)
(f 2 3) :: Int -> Int

（f 2 3）可以看作是接受一个Int并返回一个Int的函数

最后

:t (f 2 3 4)
(f 2 3 4) :: Int

具有高阶函数的示例：

h :: (Int -> Int -> Int) -> Int -> Int -> Int
h fn x y = fn x y

稍微复杂一点，但思路相同：

:t (h f)
(h f) :: Int -> Int -> Int -> Int

(hf)是一个函数，需要一个Int ，然后返回（Int-> Int-> Int-> Int）

但是...等等，它不是期望返回一个函数吗？ 应该是这样

(h f) :: Int -> Int -> (Int -> Int)

好吧，点了。 让我们继续

:t (h f 2)
(h f 2) :: Int -> Int -> Int

(hf 2)是一个期待一个Int并返回一个函数的函数（Int-> Int）

最后

 :t (h f 2 3)
(h f 2 3) :: Int -> Int

(hf 2 3)确实是一个函数，期望一个Int ，返回一个Int

(h f 2 3) 4 == 7

我认为这里的结论是， 每个函数都在Haskell中进行管理 。