为什么（a - ＆gt;（b - ＆gt; c））为函数定义中的第一个参数，而是类型签名中的第二个参数？

Question

如果通过函数为函数应用程序的第一个参数是左求解的，例如：

drop 2 [1,2,3,4]

结果：[3,4]

等同于

(drop 2) [1,2,3,4]

相同的结果：[3,4]

在这里我的问题是，如果类型签名是正确的缔合性，则意味着，右侧的事物首先评估，在这种情况下，它将如下，因为第一个参数首先是由函数获取的：

drop :: [1,2,3,4] -> (2 -> [3,4])

它应该是' T如下，对吗？

drop :: Int -> ([a] -> [a])
drop :: 2 -> ([1,2,3,4] -> [3,4])

那么，为什么它首先在函数的类型签名中首先使用第二个参数，而不是第一个参数？

另外，如果在第一个参数之前评估了第二个参数，那么为什么以下用法无效？

(drop [1,2,3,4]) 2

Answer 1

写drop :: [1,2,3,4] - ＆gt之类的东西是荒谬的。 （2 - ＆gt; [3,4]）或2-＆gt; （[1,2,3,4] - ＆gt; [3,4]） - 您正在混合那里的类型级别和值级符号。相反，您应该做的是查看本地类型的子表达：

drop                  2    [1,2,3,4]
└─┬┘                  ┊    └──┬────┘
┌─┴───────────────┐ ┌─┴─┐  ┌──┴──┐
│Int->[Int]->[Int]│ │Int│  │[Int]│
└─────────────────┘ └───┘  └─────┘

添加隐含的括号

(drop                   2)    [1,2,3,4]
 └┬─┘                   ┊     └──┬────┘
┌─┴─────────────────┐ ┌─┴─┐   ┌──┴──┐
│Int->([Int]->[Int])│ │Int│   │[Int]│
└───────────────────┘ └───┘   └─────┘

，现在subxpression drop 2表示您正在应用参数2作为该参数的第一个参数函数drop，即在其签名中为int。对于整个drop 2表达式，因此该参数已经消失：

(           drop           2   )  [1,2,3,4]
┊  ┌──────────┴────────┐ ┌─┴─┐ ┊  └──┬────┘
┊  │Int->([Int]->[Int])│ │Int│ ┊     ┊
┊  └───────────────────┘ └───┘ ┊     ┊
└────────────┬─────────────────┘  ┌──┴──┐
        ┌────┴───────┐            │[Int]│
        │[Int]->[Int]│            └─────┘
        └────────────┘

这类似于应用单个argument函数length :: [bool] - ＆gt; int到单个参数[false，true] :: [bool]获得结果length [false，true]◦（2 :: int） 。对于drop，结果具有类型（[int] - ＆gt; [int]）而不是int is在这个阶段无关。

然后，在外部级别，您要应用类型[int] - ＆gt; [int]的函数。然后，整个过程只有结果类型[int]。

( (           drop           2   )  [1,2,3,4] )
┊ ┊  ┌──────────┴────────┐ ┌─┴─┐ ┊  └──┬────┘ ┊
┊ ┊  │Int->([Int]->[Int])│ │Int│ ┊     ┊      ┊
┊ ┊  └───────────────────┘ └───┘ ┊     ┊      ┊
┊ └────────────┬─────────────────┘     ┊      ┊
┊         ┌────┴───────┐            ┌──┴──┐   ┊
┊         │[Int]->[Int]│            │[Int]│   ┊
┊         └────────────┘            └─────┘   ┊
└────────────────────────┬────────────────────┘
                      ┌──┴──┐
                      │[Int]│
                      └─────┘

Answer 2

我认为您误解了正确的联想意义。确实意味着：

drop :: Int -> [a] -> [a]

相当于：

drop :: Int -> ([a] -> [a])

因此，这意味着drop是一个采用类型int的参数，然后返回a 函数类型[a] - ＆gt; [a]。

但是功能应用程序本身是左求解。实际上：

drop 2 [1,2,3,4]

缩短了：

(drop 2) [1,2,3,4]

此处drop 2将返回类型[a] - ＆gt的函数； [A]将删除列表的前两个项目。然后，我们将[1,2,3,4]应用于该功能，从而获得[3,4]。

Answer 3

我想我现在已经理解了这个难题：

在功能应用程序中，该函数将始终从左到右接一个，因为它具有左右相关性。它的目的是用参数替换结合变量。

现在，当涉及该函数的键入签名时，它确实是正确的缔合性，但这并不意味着该函数将通过进行最后一个参数，然后是第二个参数来应用。

功能应用程序：

（（（（（（a）b）c）d）e

表示以下表达式具有以下类型：

a :: b -> (c -> (d -> e))
a    b ::  c -> (d -> e)
(a   b)    c ::  d -> e
((a  b)    c)    d :: e

可以读取为：函数采用第一个参数（b）并返回第二个函数（c - ＆gt;（d - ＆gt; e）），采用第二个参数（c）并返回第三个函数（d - ＆gt; e），该功能（d - ＆gt; e）获取第三参数（d）并返回最终结果（e ）。

正如@Daniel Wagner指出的那样：

关联顺序并不意味着函数的评估顺序。

在这种情况下，类型签名中的右求解等效如下，一对括号（c - ＆gt; d）是指通过（b）从左侧：

a :: b -> (c -> d)

由于Haskell中的功能基于Lambda cyculus，因此我将在这里使用lambdas，因为我熟悉它们，作为示例：

原始版本：

  (λab.a+b) (1,2)
= (a+b)[a:=1,b:=2]
= 1+2
= 3

但是，由于Lambda cyculus中的抽象仅在每个步骤中仅接受一个输入，因此可以被重写为：

咖喱版本：

  (λa.(λb.a+b)) 1 2
= ((λb.a+b)[a:=1]) 2
= (λb.1+b) 2
= (1+b)[b:=2]
= 1+2
= 3

注意：本文的术语或逻辑可能不正确。如果您能够并希望，可以编辑我的帖子以纠正它。 :)