在 Haskell 中，“更高级的类型”真的是类型吗？或者它们仅仅表示*具体*类型的集合而仅此而已？

参数多态函数

考虑以下函数：

f :: a -> Int
f x = (1 :: Int)

我们可以说，这种类型f is a -> Int， 然后f因此是“多态”类型。

以下哪项是最准确的思考方式f?

1. 事实上有一个single f类型的a -> Int。然而，它可以用作f :: Int -> Int, as an f :: Double -> Int，等等。

2. 从字面意思上来说，类型f is NOT a -> Int。事实上，这只是一种简写方式，表示存在family函数数f其类型是具体的（即，有一个f :: Int -> Int, an f :: Double -> Double，等等；而且，这些功能中的每一个都是互不相同的）。

高等种类

同样，我们可以考虑以下类型声明：

data Maybe a = Just a | Nothing

并询问两种观点哪种更正确：

1. 没有single type Maybe;事实上，只有一系列具体类型（Maybe Int, Maybe String等）仅此而已。

2. 有in fact单一类型Maybe。这种类型是高等类型。当我们说它是一种“类型”时，我们指的是字面意思（不是（1）的简写）。正好我们也可以这样写Maybe Int, Maybe Double，依此类推生成distinct类型（恰好是具体的）。但是，归根结底（即）：Maybe, Maybe Int, and Maybe String denote three不同的类型，其中两种是具体的，另一种是更高级的。

问题总结

在 Haskell 中，“高等类型”真的是类型吗？或者只是具体类型“真实类型”，当我们谈到“更高种类的类型”时，我们仅仅表示一种family具体类型。此外，参数多态函数是否表示单一型，或者他们merely表示一个收藏的功能具体类型（仅此而已）？

目前尚不完全清楚您想问什么，以及两种情况下 1 和 2 之间的实际差异是什么，但从基本的数学角度来看：

参数多态函数

f实际上有类型f :: forall a.a->int

对于 Haskell 所基于的类型化 lambda 演算中的函数来说，它是完全合法的类型。它可以是这样的：

f = λa:Type.λx:a.(body for f)

你怎么获得Double->Int从中？你apply it to Double type:

f Double = (λa:Type.λx:a.(body for f)) Double => λx:Double.(body for f|a=Double)

Haskell 在幕后执行这两种操作（类型抽象和类型应用），尽管可以显式声明forall类型签名的一部分XExplicitForAllGHC 扩展，并明确地做出Double->Int的实例f带类型签名：

f_double :: Double -> Int
f_double = f

高等种类

考虑一个简单的类型：

data Example = IntVal Int | NoVal

（是的Maybe Int).

Maybe is a type构造函数，就像IntVal is a data构造函数。这是完全相同的事情，只是“更高一级”，从某种意义上说Maybe应用于Type， 很像IntVal应用于Int.

在 lambda 演算中，Maybe有类型：

Maybe : Type->Type

Haskell 不允许您从类型构造函数中获取类型，但允许您获取kind（这只是一个奇特的名字类型的类型):

:k Maybe
Maybe :: * -> *

So no, Maybe不是一个type：你不能拥有该类型的对象Maybe. Maybe（几乎）是一个从类型到类型的函数，比如IntVal是一个从值到值的函数。

我们将申请的结果称为Maybe to String as Maybe String，就像我们所说的应用结果IntVal to 4 as IntVal 4.