类型和种类有什么区别？

我正在学习编程语言Haskell，并且试图围绕a type和a 之间的区别进行思考kind。

据我了解，a kind is a type of type。例如a ford is a type of car和a car is a kind of vehicle。

这是思考这个问题的好方法吗？

因为，我的大脑当前的连接方式是a ford is a **type** of car，但同时需要car is a **type** of vehiclea car is a **kind** of vehicle。即条款，type并且kind可以互换。

有人能对此有所启示吗？

在这里，“值”，“类型”和“种类”具有形式上的含义，因此，考虑它们的通用英语用法或对汽车进行分类的类比，只会使您到目前为止。

我的回答与在Haskell上下文中这些术语的形式含义有关。这些含义基于（尽管并不完全相同）数学/ CS“类型理论”中使用的含义。因此，这将不是一个很好的“计算机科学”答案，但是它可以作为一个很好的Haskell答案。

在Haskell（和其他语言）中，将一种类型分配给一个程序表达式是有帮助的，该程序表达式描述了允许该表达式具有的值的类别。我这里假设你已经看到了足够的例子来了解为什么它会是知道的是，在表达的sqrt (a**2 + b**2)，变量a和b将永远是类型的值Double，而不是，说，String和Bool分别。基本上，拥有类型可以帮助我们编写可在各种值上正常工作的表达式/程序。

现在，您可能尚未意识到的是Haskell类型，例如出现在类型签名中的类型：

fmap :: Functor f => (a -> b) -> f a -> f b

实际上是用类型级别的Haskell子语言编写的。程序文本Functor f => (a -> b) -> f a -> f b-从字面上看-是用此子语言编写的类型表达式。子语言包括运营商（例如，->在该语言中的右结合缀运算符），变量（例如，f，a，和b）一种类型的表达，和“应用”到另一个（例如，f a被f施加到a）。

我是否提到在许多语言中为程序表达式分配类型以描述表达式值的类有什么帮助？好吧，在这种类型级别的子语言中，表达式对类型求值（而不是value），并且最终有助于将类型分配给类型表达式以描述允许它们表示的类型的类别。基本上，拥有种类可以帮助我们编写可在各种类型上正常工作的类型表达式。

因此，值对类型就像类型对种，类型帮助我们编写价值级别的程序，而类型则帮助我们编写类型级别的程序。

做这些种什么样子的？好吧，考虑类型签名：

id :: a -> a

如果类型表达式a -> a是有效的，什么样的的类型，我们应该允许变量a是？好了，类型表达式：

Int -> Int
Bool -> Bool

看起来有效，因此类型 Int和Bool显然是正确的类型。但更复杂的类型如：

[Double] -> [Double]
Maybe [(Double,Int)] -> Maybe [(Double,Int)]

看起来很有效。实际上，由于我们应该能够调用id函数，甚至：

(a -> a) -> (a -> a)

看起来不错。所以Int，Bool，[Double]，Maybe [(Double,Int)]，和a -> a看起来都像类型正确的那种。

换句话说，似乎只有一种，我们称其*为Unix通配符，并且每种类型都有相同的种类 *，故事的结尾。

对？

好吧，不完全是。事实证明，Maybe就其本身而言，类型表达式与Maybe Int（完全一样sqrt，就其本身而言，与值表达式一样有效sqrt 25）一样有效。 但是，以下类型表达式无效：

Maybe -> Maybe

因为，虽然Maybe是一种类型的表达，它并不代表样的的类型，可以有值。所以，这就是我们应该如何定义*-这是样的的类型具有值; 它包括“完整”类型，例如Double，Maybe [(Double,Int)]但不包括不完整无价值的类型，例如Either String。为简单起见，我将这些类型的完整类型称为*“具体类型”，尽管该术语不是通用的，并且“具体类型”可能意味着与C ++程序员非常不同的东西。

现在，在类型表达式中a -> a，只要类型a具有种类 *（具体类型的种类），类型表达式的结果也a -> a将具有种类（即具体类型的种类）。 *

那么，什么样的的类型是Maybe？好了，Maybe可以应用于一种混凝土类型，以产生另一种混凝土类型。因此，Maybe看起来有点像一个类型级别的函数，该函数接受类型的类型 *并返回类型的类型 *。如果我们有这样的花了一个值水平函数值的类型 Int和返回值的类型 Int，我们想给它一个类型的签名Int -> Int，所以通过类比，我们应该给Maybe一个样的签名* -> *。GHCi同意：

> :kind Maybe
Maybe :: * -> *

回到：

fmap :: Functor f => (a -> b) -> f a -> f b

在这种类型的签名，变量f有一种* -> *和变量a，并b有样*; 内置运算符->具有kind * -> * -> *（它*在左侧需要一个type，在右侧需要一个type，并且还返回一个type *）。从这个善良的推理规则，你可以推断出a -> b是一个有效的类型与种类*，f a并且f b也有效类型的一种*，并且(a -> b) -> f a -> f b是一种有效的类型*。

换句话说，编译器可以“类型检查”类型表达式(a -> b) -> f a -> f b以验证其对正确类型的变量是否有效，就像“类型检查” sqrt (a**2 + b**2)以验证其对正确类型的变量有效一样。

对“类型”和“种类”使用单独的术语的原因（即，不谈论“类型的类型”）主要是为了避免混淆。上面的种类看起来与类型完全不同，并且至少在一开始似乎表现出很大的不同。（例如，它需要一些时间来环绕，每一个“正常”的类型有同种想法你的头*和那种a -> b是*不是* -> *。）

其中一些也是历史性的。随着GHC Haskell的发展，值，类型和种类之间的区别开始变得模糊。如今，可以将值“提升”为类型，而类型和种类实际上是同一回事。因此，在现代的Haskell中，值（几乎）都具有类型和ARE类型，而类型的种类仅仅是更多类型。

@ user21820要求对“类型和种类确实是同一件事”进行一些补充说明。更清楚一点，在现代GHC Haskell（我认为是从8.0.1版本开始）中，类型和种类在大多数编译器代码中都得到统一处理。编译器会在错误消息中做出一些努力，以区分是“类型”还是“种类”，这取决于编译器分别抱怨值的类型还是类型的类型。

另外，如果未启用任何扩展名，则可以使用表面语言轻松区分它们。例如，类型（值）在语法中具有表示形式（例如，在类型签名中），但是（我认为）类型（类型）是完全隐式的，并且在它们出现的地方没有显式语法。

但是，如果您打开适当的扩展名，类型和种类之间的区别就会消失。例如：

{-# LANGUAGE GADTs, TypeInType #-}
data Foo where
  Bar :: Bool -> * -> Foo

在这里，Bar（既是值又是）类型。作为类型，它的种类是Bool -> * -> Foo，这是一个类型级别的函数，它接受一个种类的类型Bool（既是一个种类，又是一个种类）和一个种类，*并产生一个种类Foo。所以：

type MyBar = Bar True Int

正确进行种类检查。

正如@AndrejBauer在他的回答中所解释的那样，未能区分类型和种类是不安全的-具有*类型/种类本身（在现代Haskell中就是这种情况）的类型/种类会导致自相矛盾。但是，由于未终止，Haskell的类型系统已经充满了悖论，因此这并不重要。

如果您了解集合论中集合与类之间的区别，那么将问题考虑为可能会有所帮助 如果不是，您可以将种类视为“大”或“高级”类型，其元素可以是类型，也可以以某种方式涉及类型。例如：

• Bool 是一种
• Type 是一种，因为其元素是类型
• Bool -> Int 是一种
• Bool -> Type 是一种，因为其元素是返回类型的函数
• Bool * Int 是一种
• Bool * Type 是一种，因为其元素与一个组件成对

$U_0$$U_1$$U_2$$U_0$$\mathtt{Bool}$$\mathtt{Nat}$$\mathtt{Nat} \to \mathtt{Nat}$$U_1$$U_0$$\mathtt{Bool} \to U_0$$U_0 \to U_0$$U_{n+1}$$U_n$$U_n$$\times$$\to$

$U_0$$U_1$$U_0$$U_1$$U_0$**U_1

一个值就像您坐在车道上的红色2011福特野马，上面有19206英里。

非正式地，该特定值可以有多种类型：它是野马，它是福特，它是汽车，它是车辆，以及许多其他可以组成的类型（“事物”的类型属于您”或“红色事物”的类型，或...）。

（在Haskell中，一阶近似（GADT破坏了此属性，数字文字和OverloadedStrings扩展的魔力使它模糊了一点），值具有一个主要类型，而不是过多的非正式“类型”，您可以将' stang。42是（为了便于说明）Int； Haskell中没有“数字”或“偶数整数”的类型-确切地说，您可以创建一个，但它与Int。是不相交的类型。）

现在，“野马”可能是“汽车” 的子类型 -野马的每个值也都是汽车。但是，类型 -或者，使用Haskell的术语中，那种 “野马”是不是“车”。“ Mustang”类型不是您可以停放在车道上或四处行驶的东西。“ Mustang”是名词，类别或类型。这些都是非正式的各种 “野马”的。

（同样，Haskell对于每个类型级别的事物仅识别一种。因此，Int具有kind *，没有其他种类。Maybe具有kind * -> *，没有其他种类。但是直觉应该仍然成立：42是an Int，您可以Int用它来做点事情就像加法和减法，Int它本身不是一个Int；没有这样的数字Int + Int。您可能会非正式地听到人们说Int是a Num，这表示他们有一个该类型的类型类的实例 —这不是同一件事话说有样。有一种“类型”，这在Haskell拼写）。NumIntInt NumInt*

那么，不是每个非正式的“类型”都是名词还是类别？所有类型都具有相同的种类吗？如果太无聊，为什么还要谈论种类呢？

在这里，英语的类比可能会有些摇摆不定，但请允许我：假装英语中的“拥有者”一词没有孤立的意义，而没有描述事物的所有权。假装有人称您为“所有者”，那对您完全没有意义；但是如果有人称您为“车主”，您就可以理解他们的意思。

“所有者”就不会有同样的是“车”，因为你可以谈论一辆车，但你能不能谈谈在英语的本作后续版本的所有者。您只能谈论“车主”。当“所有者”应用于已经具有“名词”种类的东西（例如“汽车”）时，它只会创建“名词”种类的东西。我们可以说“所有者”的种类是“名词->名词”。“所有者”就像一个函数，它接受一个名词并从中产生一个不同的名词。但这本身不是名词。

请注意，“车主”不是“车”的子类型！它不是接受或返回汽车的功能！它只是与“汽车”完全不同的类型。它描述了两条手臂和两条腿的价值，他们在某一时刻拥有一定数量的钱，然后将这些钱带给经销店。它没有描述具有四个轮子和油漆作业的值。另请注意，“汽车所有者”和“狗所有者”是不同的类型，您可能要对其中一个进行的操作可能不适用于另一个。

（同样，当我们在Haskell中说“ Maybe有一种” * -> *时，我们的意思是谈论“ a Maybe” 是荒谬的（正式；非正式地，我们一直在做）。相反，我们可以有a Maybe Int或a Maybe String，因为这些是种类）*。

因此，讨论所有类型的全部目的是使我们可以围绕诸如“所有者”之类的词来形式化我们的推理，并强制我们只采用“完全构建”且并非荒谬的类型的值。

据我了解，一种是一种类型。

是的-所以让我们探究这意味着什么。 Int或者Text是具体的类型，但是Maybe a是一个抽象的类型。直到您确定要为a特定变量（或值/表达式/什么）指定的特定值（例如），它才会成为具体类型Maybe Text。

我们说这Maybe a是一个类型构造函数，因为它就像一个接受单个具体类型（例如Text）并返回具体类型（Maybe Text在这种情况下）的函数。但是其他类型构造函数在返回具体类型之前可能会使用更多的“输入参数”。例如，在构造具体类型（）之前，Map k v需要采用两种具体类型（例如Int和）。TextMap Int Text

因此，Maybe a和List a类型构造函数具有相同的“签名”，我们将其称为* -> *（类似于Haskell函数签名），因为如果给它们一个具体类型，它们将吐出一个具体类型。我们称这种类型为“种类”，Maybe并且List具有相同的种类。

具体类型被称为具有kind *，而我们的Map示例是kind，* -> * -> *因为在输出具体类型之前需要将两个具体类型作为输入。

您可以看到，它几乎只不过是我们传递给类型构造函数的“参数”的数量-但要意识到，我们也可能将类型构造函数嵌套在类型构造函数内部，因此我们最终可以得到一种* -> (* -> *) -> *例如。

如果您是Scala / Java开发人员，则可能还会发现以下说明很有用：https : //www.atlassian.com/blog/archives/scala-types-of-a-higher-kind