11

我发现自己真的无法理解“通用类型”和“高级类型”之间的区别。

斯卡拉代码：

trait Box[T]

我定义了一个trait名字是 的Box，它是一个接受参数类型的类型构造函数T。（这句话对吗？）

我也可以说：

  1. Box是泛型类型
  2. Box是高级类型
  3. 以上都不是正确的

当我与同事讨论代码时，我经常在“通用”和“高级”两个词之间挣扎来表达它。

4

2 回答 2

4

现在回答可能为时已晚，您现在可能已经知道其中的区别，但我将回答只是为了提供另一种观点，因为我不太确定 Greg 所说的是否正确。泛型比更高种类的类型更通用。许多语言，如 Java 和 C# 都有泛型，但很少有更高种类的类型。

要回答您的具体问题，是的，Box是带有类型参数的类型构造函数T。您也可以说它是泛型类型，尽管它不是更高种类的类型。下面是一个更广泛的答案。

这是泛型编程的维基百科定义：

通用编程是一种计算机编程风格，其中算法是根据稍后指定的类型编写的，然后在需要时为作为参数提供的特定类型实例化。这种方法由 ML 于 1973 年首创，1允许编写通用函数或类型，这些函数或类型仅在使用时操作的类型集有所不同，从而减少了重复。

假设您Box这样定义。它拥有某种类型的元素，并有一些特殊的方法。它还定义了一个map函数，类似于Iterableand Option，因此您可以将一个包含整数的盒子变成一个包含字符串的盒子，而不会丢失所有那些Box具有的特殊方法。

case class Box(elem: Any) {
  ..some special methods
  def map(f: Any => Any): Box = Box(f(elem))
}

val boxedNum: Box = Box(1)
val extractedNum: Int = boxedString.elem.asInstanceOf[Int]
val boxedString: Box = boxedNum.map(_.toString)
val extractedString: String = boxedString.elem.asInstanceOf[String]

如果Box这样定义，你的代码会因为所有对 的调用而变得非常丑陋asInstanceOf，但更重要的是，它不是类型安全的，因为一切都是 Any。

这就是泛型有用的地方。假设我们这样定义Box：

case class Box[A](elem: A) {
  def map[B](f: A => B): Box[B] = Box(f(elem))
}

然后我们可以将我们的map函数用于各种事情，比如更改内部的对象，Box同时仍然确保它在Box. 在这里，没有必要，asInstanceOf因为编译器知道您的Boxes 的类型以及它们所持有的内容（甚至不需要类型注释和类型参数）。

val boxedNum: Box[Int] = Box(1)
val extractedNum: Int = boxedNum.elem
val boxedString: Box[String] = boxedNum.map[String](_.toString)
val extractedString: String = boxedString.elem

泛型基本上可以让你抽象不同的类型，让你使用Box[Int]和Box[String]作为不同的类型，即使你只需要创建一个Box类。

但是，假设您无法控制此类Box，它仅定义为

case class Box[A](elem: A) {
  //some special methods, but no map function
}

假设您使用的这个 API 还定义了它自己的类Option和List类（都接受一个表示元素类型的类型参数）。现在您希望能够映射所有这些类型，但是由于您不能自己修改它们，因此您必须定义一个隐式类来为它们创建扩展方法。Mappable让我们为扩展方法和 typeclass添加一个隐式类Mapper。

trait Mapper[C[_]] {
  def map[A, B](context: C[A])(f: A => B): C[B]
}

implicit class Mappable[C[_], A](context: C[A])(implicit mapper: Mapper[C]) {
  def map[B](f: A => B): C[B] = mapper.map(context)(f)
}

您可以像这样定义隐式映射器

implicit object BoxMapper extends Mapper[Box] {
  def map[B](box: Box[A])(f: A => B): Box[B] = Box(f(box.elem)) 
}
implicit object OptionMapper extends Mapper[Option] {
  def map[B](opt: Option[A])(f: A => B): Option[B] = ???
}
implicit object ListMapper extends Mapper[List] {
  def map[B](list: List[A])(f: A => B): List[B] = ???
}
//and so on

并使用它，就好像Box, Option,List等一直有map方法一样。

这里Mappable和Mapper是更高种类的类型，而Box、Option和List是一阶类型。它们都是泛型类型和类型构造函数。Int然而和String是正确的类型。这是它们的种类，（种类对类型就像类型对值一样）。

//To check the kind of a type, you can use :kind in the REPL
Kind of Int and String: *
Kind of Box, Option, and List: * -> *
Kind of Mappable and Mapper: (* -> *) -> *

类型构造函数有点类似于函数（有时称为值构造函数）。正确的类型 (kind *) 类似于简单的值。它是一种具体类型，可用于返回类型、变量类型等。您可以直接说val x: Int而不传递Int任何类型参数。

一阶类型（kind * -> *）就像一个看起来像的函数Any => Any。它不是取一个值并给你一个值，而是取一个类型并给你另一种类型。val x: List如果不给它们类型参数（有效），就不能直接使用一阶类型（无效val x: List[Int]）。这就是泛型所做的——它允许您对类型进行抽象并创建新类型（JVM 只是在运行时删除该信息，但像 C++ 这样的语言实际上会生成新的类和函数）。Cin的类型参数Mapper也是这种类型。下划线类型参数（你也可以使用其他东西，比如x）让编译器知道它C是 kind * -> *。

高阶类型/高阶类型就像高阶函数——它接受另一个类型的构造函数作为参数。你不能使用 a Mapper[Int]above，因为C应该是 kind * -> *（这样你就可以做C[A]and C[B]），而Intis只是*. 只有在 Scala 和 Haskell 等具有更高类型类型的语言中，您才能创建Mapper上述类型以及其他类型系统更有限的语言（如 Java）之外的东西。

这个关于类似问题的答案（和其他人）也可能有所帮助。

编辑：我从同一个答案中窃取了这张非常有用的图片：

在此处输入图像描述

于 2020-06-29T15:50:39.580 回答
-4

“高级类型”和“泛型”之间没有区别。

Box是“结构”或“上下文”，T可以是任何类型。

所以T在英语意义上是通用的……我们不知道它会是什么，我们也不在乎，因为我们不会T直接操作。

C# 也将这些称为泛型。我怀疑他们选择这种语言是因为它的简单性（为了不吓跑人们）。

于 2018-11-17T05:37:32.957 回答