Scala中什么是更高种类的类型？

您可以在网上找到以下内容：

1. 更高种类的类型==类型构造函数？

   class AClass[T]{...} // For example, class List[T]

   有人说这是一种更高种类的类型，因为它抽象了符合该定义的类型。

   较高种类的类型是采用其他类型并构造新类型的类型

   这些虽然也称为类型构造函数。（例如，在Scala编程中）。

2. 更高种类的类型==类型构造函数，它将类型构造函数作为类型参数？

   在高级类属的论文中，您可以阅读

   ...在类型上进行抽象的类型，在类型上进行抽象（“高级类型”）...”

   这表明

   class XClass[M[T]]{...} // or
   
   trait YTrait[N[_]]{...} // e.g. trait Functor[F[_]]
   

   是一种较高的类型。

因此，考虑到这一点，很难区分类型构造函数，更高种类的类型和将类型构造函数作为类型参数的类型构造函数，因此存在上述问题。

让我通过消除歧义消除一些混乱。我喜欢用价值水平的类比来解释这一点，因为人们往往更熟悉它。

类型构造函数是一种类型，您可以将其应用于类型参数以“构造”一个​​类型。

值构造函数是一个值，您可以将其应用于值参数以“构造”值。

值构造函数通常称为“函数”或“方法”。这些“构造函数”也被称为“多态的”（因为它们可用于构造变化的“形状”的“东西”）或“抽象”（因为它们抽象化了不同的多态实例之间的变化）。

在抽象/多态性的上下文中，一阶是指抽象的“单次使用”：您一次对某个类型进行了抽象，但是该类型本身无法对任何事物进行抽象。Java 5泛型是一阶的。

上述抽象特征的一阶解释是：

类型构造函数是一种类型，您可以将其应用于适当的类型参数以“构造”适当的类型。

值构造函数是一个值，您可以将其应用于适当的值参数以“构造”适当的值。

为了强调不涉及任何抽象（我想您可以称其为“零阶”，但我从未见过在任何地方使用过这种抽象），例如value 1或type String，我们通常说某种东西是“ proper”值或type。

适当的值在某种意义上是“立即可用的”，因为它不等待参数（它不会抽象化它们）。可以将它们视为可以轻松打印/检查的值（序列化功能就是作弊！）。

适当的类型是对值进行分类的类型（包括值构造函数），类型构造函数不对任何值进行分类（首先需要将它们应用于正确的类型参数以产生适当的类型）。要实例化一个类型，有必要（但不足以满足）是一个适当的类型。（它可能是抽象类，也可能是您无权访问的类。）

“高阶”只是一个通用术语，表示重复使用多态性/抽象。对于多态类型和值，这意味着同一件事。具体而言，高阶抽象是对某物的抽象，而某物是对某物的抽象。对于类型，术语“高级”是更通用的“高级”的专用版本。

因此，我们表征的高阶版本变为：

类型构造函数是一种类型，您可以将其应用于类型实参（适当的类型或类型构造函数）以“构造”适当的类型（构造函数）。

值构造函数是一个值，您可以将其应用于值参数（适当的值或值构造函数）以“构造”适当的值（构造函数）。

因此，“高阶”只是意味着当您说“抽象X”时，您的意思是真的！该X被抽象在不失去自己的“抽象权利”：它可以抽象所有就是了。（顺便说一句，我在这里使用动词“抽象”是指：省略了对于值或类型的定义不是必不可少的东西，以便抽象的用户可以将其更改/提供为参数） ）

以下是一些适当，一阶和高阶值和类型的示例（受Lutz的电子邮件启发）：

                   proper    first-order           higher-order

values             10        (x: Int) => x         (f: (Int => Int)) => f(10)
types (classes)    String    List                  Functor
types              String    ({type λ[x] = x})#λ   ({type λ[F[x]] = F[String]})#λ

使用的类定义为：

class String
class List[T]
class Functor[F[_]]

为了避免通过定义类进行间接操作，您需要以某种方式表示匿名类型的函数，这些函数在Scala中无法直接表达，但是您可以使用结构类型，而没有太多的语法开销（#λ-style是由于https://stackoverflow.com / users / 160378 / retronym afaik）：

在某些支持匿名类型函数的Scala假想未来版本中，您可以将示例的最后一行缩短为：

types (informally) String    [x] => x              [F[x]] => F[String]) // I repeat, this is not valid Scala, and might never be

（就我个人而言，我很遗憾曾经谈论过“高类型类型”，毕竟它们只是类型！当您绝对需要消除歧义时，我建议您说“类型构造器参数”，“类型构造器成员” ，或“类型构造函数别名”，以强调您并不是在谈论适当的类型。）

ps：进一步使事情复杂化的是，“多态”以不同的方式模棱两可，因为多态类型有时表示通用的量化类型，例如Forall T, T => T，这是适当的类型，因为它对多态值进行了分类（在Scala中，该值可以是写成结构类型{def apply[T](x: T): T = x}）

（此答案是通过一些图形和历史信息来修饰Adriaan Moors答案的尝试。）

从2.5开始，更高种类的类型是Scala的一部分。

• 在此之前，Scala直到现在仍像Java一样，不允许将类型构造函数（Java中的“泛型”）用作类型构造函数的类型参数。例如

   trait Monad [M[_]]

  不可能的。

  在Scala 2.5中，类型系统已通过在更高级别上对类型进行分类的能力得到扩展（称为类型构造函数多态性）。这些分类称为种类。

  （图片来自高级泛型）

  结果是，类型构造函数（例如List）可以像其他类型一样在类型构造函数的类型参数位置使用，因此自Scala 2.5起，它们成为第一类类型。（类似于Scala中一流的函数）。

  在一种类型的系统中支持更高种上下文中，我们可以区分合适类型，种类等Int或List[Int]从第一阶类型，如List和类型更高的种像Functor或Monad（类型的抽象以上类型的抽象以上类型）。

  另一方面，Java的类型系统不支持种类，因此没有“高级种类”的类型。

  因此，必须在支持类型系统的背景下才能看到这一点。

• 对于Scala，您经常会看到类型构造器的示例，例如

   trait Iterable[A, Container[_]]

  标题为“更高种类的类型”，例如在Scala中，针对通用程序员，第4.3节

  这有时missleading，因为很多是指Container为提高kinded类型，而不是Iterable，但更精确的是，

  在此使用Container类型较高的类型（较高阶）的类型构造函数参数Iterable。

该种普通类型，如Int和Char，其实例是价值观，是*。一元类型构造器的类型Maybe是* -> *; 二进制类型的构造函数，例如Eitherhave（curried）kind * -> * -> *，等等。您可以像Maybe和Either作为类型级别的函数一样查看类型：它们接受一个或多个类型，然后返回一个类型。

如果函数的阶数大于1，则该函数为高阶函数，其中该阶数（非正式地）是函数箭头的嵌套深度：

• 订单0： 1 :: Int
• 顺序1： chr :: Int -> Char
• 顺序2 ：fix :: (a -> a) -> a，map :: (a -> b) -> [a] -> [b]
• 顺序3： ((A -> B) -> C) -> D
• 订单4： (((A -> B) -> C) -> D) -> E

因此，长话短说，种类繁多的类型只是类型级别的高阶函数。

• 订单0： Int :: *
• 顺序1： Maybe :: * -> *
• 顺序2：Functor :: (* -> *) -> Constraint—种类较多：将一元类型构造函数转换为类型限制

我会说：更高种类的类型比类型构造函数抽象。例如考虑

trait Functor [F[_]] {
   def map[A,B] (fn: A=>B)(fa: F[A]): F[B]
}

这Functor是“更高种类的类型”（如“更高种类的泛型 ”中所使用）。它不是一个具体的（“一阶”）类型构造函数List（仅对适当的类型进行抽象）。它抽象了所有一元（“一阶”）类型的构造函数（用表示F[_]）。

或者List<T>换一种说法：在Java中，我们显然有类型构造函数（例如），但是我们没有“更高种类的类型”，因为我们不能对它们进行抽象（例如，我们不能编写Functor上面定义的接口-至少不是直接）。

术语“高阶（类型构造函数）多态性”用于描述支持“高阶类型”的系统。

Scala REPL提供:kind命令

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

例如，

scala> trait Foo[A]
trait Foo

scala> trait Bar[F[_]]
trait Bar

scala> :kind -v Foo
Foo's kind is F[A]
* -> *
This is a type constructor: a 1st-order-kinded type.

scala> :kind -v Foo[Int]
Foo[Int]'s kind is A
*
This is a proper type.

scala> :kind -v Bar
Bar's kind is X[F[A]]
(* -> *) -> *
This is a type constructor that takes type constructor(s): a higher-kinded type.

scala> :kind -v Bar[Foo]
Bar[Foo]'s kind is A
*
This is a proper type.

这些:help提供了明确的定义，因此我认为值得将其完整发布在此处（Scala 2.13.2）

scala> :help kind

:kind [-v] <type>
Displays the kind of a given type.

    -v      Displays verbose info.

"Kind" is a word used to classify types and type constructors
according to their level of abstractness.

Concrete, fully specified types such as `Int` and `Option[Int]`
are called "proper types" and denoted as `A` using Scala
notation, or with the `*` symbol.

    scala> :kind Option[Int]
    Option[Int]'s kind is A

In the above, `Option` is an example of a first-order type
constructor, which is denoted as `F[A]` using Scala notation, or
* -> * using the star notation. `:kind` also includes variance
information in its output, so if we ask for the kind of `Option`,
we actually see `F[+A]`:

    scala> :k -v Option
    Option's kind is F[+A]
    * -(+)-> *
    This is a type constructor: a 1st-order-kinded type.

When you have more complicated types, `:kind` can be used to find
out what you need to pass in.

    scala> trait ~>[-F1[_], +F2[_]] {}
    scala> :kind ~>
    ~>'s kind is X[-F1[A1],+F2[A2]]

This shows that `~>` accepts something of `F[A]` kind, such as
`List` or `Vector`. It's an example of a type constructor that
abstracts over type constructors, also known as a higher-order
type constructor or a higher-kinded type.