问为什么这两个函数有不同的类型？

EN

导出(\f b -> (\a -> a) f b b)的类型

那么，让我们尝试导出表达式的类型：

(\f b -> (\a -> a) f b b)

或者更详细：

(\f -> (\b -> (((\a -> a) f) b) b))

我们在这里看到，这是一个接受两个参数的函数(从技术上讲，函数总是有一个参数，这个函数的结果可以是另一个参数，但是假设如果我们讨论“两个参数”，我们指的是这样的结构)。

因此，参数是f和b，最初我们对这些参数不太了解，因此我们为它们分配了一个类型，表达式如下：

f :: g
b :: h
(\f b -> (\a -> a) f b b) :: g -> (h -> i)

因此，我们创建了三种类型的g、h和i (这里我使用了a、b和c以外的其他标识符，因为这可能导致与变量混淆)。

但是我们还没有完成，因为表达式本身可以对类型的行为带来更多的限制。例如，我们看到一个lambda表达式：\a -> a，它显然具有类型：

\a -> a :: j -> j

接下来，我们看到一个函数应用程序，函数是\a -> a，参数是f，这意味着g ~ j (g和j是相同的类型)，(\a -> a) f的类型是(\a -> a) f :: g。

但是我们还没有完成，因为(\a -> a) f的结果现在在b的函数应用程序中充当一个函数，因此这意味着g实际上是一个函数，具有输入类型h和一些(当前未知的输出类型)，因此：

g ~ (h -> k)

所以(\a -> a) f b的类型是k，但是我们还没有完成，因为我们执行另一个函数应用程序，(\a -> a) f b作为函数(类型k)，b作为参数，这意味着k实际上是一个函数，h是参数类型，结果是表达式的类型，所以i。这意味着我们有：

g ~ j
g ~ (h -> k)
k ~ (h -> i)

换句话说，表达式的类型是：

(\f b -> (\a -> a) f b b) :: (h -> (h -> i)) -> (h -> i)

或者不那么冗长：

(\f b -> (\a -> a) f b b) :: (h -> h -> i) -> h -> i

导出(\f b -> (\a -> 0) f b b)的类型

派生的第一步大致相同，我们首先引入一些类型变量：

f :: g
b :: h
(\f b -> (\a -> 0) f b b) :: g -> (h -> i)

现在我们开始做推论。我们首先推断出(\a -> 0)的类型。这是一个函数，类型为Num l => j -> l，因为0是Number，但它可以是任何Num类型，并且与参数a的类型无关。

接下来，我们看到有一个函数调用，函数以(\a -> 0)为函数，f为参数，因此我们得出了g ~ j的结论。此函数调用的结果类型为(\a -> 0) f :: Num l => l。

现在我们看到了另一个函数调用，函数是(\a -> 0) f，参数是b。因此，我们得出结论，l是一个函数(所以是l ~ (h -> k))。

最后一个函数调用是以(\a -> 0) f b :: k作为函数，b再次作为参数。这意味着k是一个函数k ~ h -> i。因此，我们得到了以下类型和等式：

f :: g
b :: h
(\a -> 0) :: Num l => j -> l
(\f b -> (\a -> 0) f b b) :: g -> (h -> i)
g ~ j
l ~ (h -> k)
k ~ (h -> i)

因此，表达式的类型如下：

(\f b -> (\a -> 0) f b b) :: g -> (h -> i)

或者更具体地说：

(\f b -> (\a -> 0) f b b) :: Num (h -> (h -> i)) => g -> (h -> i)

或者不那么冗长：

(\f b -> (\a -> 0) f b b) :: Num (h -> h -> i) => g -> h -> i

因此，既然我们使用(\a -> 0)作为内部lambda表达式，那么f的类型和值就不再相关了。(\a -> 0) f将始终返回0，这应该是一个可以考虑b的函数。

至少从理论上看，作为Num的函数没有什么“奇怪”(只要它支持应该由Num类型实现的函数)。例如，我们可以实现一个函数instance Num (a -> b -> Int)，从而将0看作总是映射到0的常量函数，而(+)则是构造将这两个函数相加在一起的新函数的一种方法。