scala中什么是类型，什么是类型构造函数

我对

scala

中

type

的含义理解有点困惑

在文档中我读到，

List[Int]

是一个类型，List是一个类型构造函数

但是当我写以下内容时，关键字

type

是什么意思呢

val ls: scala.collection.immutable.List.type = scala.collection.immutable.List

---

以及该

类型

如何与可定义为特征中的字段的

类型

相关

在scala

val

赋值中，如上所示：

val name: Tpe = expression

Tpe

是标识符的类型

name

。因此：

val x: List.type = List

List

对象（又称列表模块或列表伴侣）的类型为

List.type

。这表明它是一个单体。所有这些都与类型理论中类型构造函数的概念完全正交

类型构造函数 在类型理论中，

List

（注意：不是附带的）既是一个类型（表示为

*

）又是一个类型构造函数（表示为

*->*

），因为当您向

List

（例如Int）提供一个类型参数时，您就有了一个类型（即

List[Int]

）。Scala为这种构造提供了语法。例如：

def foo[F[_]]: F[Int]
        ^^^^     ^^^
         |        + supply a type argument to F[_]  
         |
         + the type constructor F[_] 

scala> def foo[F[_]]: F[Int] = ???
foo: [F[_]]=> F[Int]

scala> lazy val x = foo[List]
x: List[Int] = <lazy>

但是，除非您对

F

了解更多，否则无法真正实现这种方法。例如，如果存在一个隐式的

scalaz.Monad[F]

，则可以使用

Monad.pure

值来构造

F[Int]

，如下所示：

def foo[F[_]: Monad]: F[Int] = Monad[F].pure(1)

在斯卡拉 Scala确实允许您将

List

作为类型构造函数作为类型参数传递给这样的方法。例如：

def foo[F[_]]: F[Int]
        ^^^^     ^^^
         |        + supply a type argument to F[_]  
         |
         + the type constructor F[_] 

scala> def foo[F[_]]: F[Int] = ???
foo: [F[_]]=> F[Int]

scala> lazy val x = foo[List]
x: List[Int] = <lazy>

当我写以下内容时，关键字类型是什么意思

type

是在Scala中的

object

上定义的成员

假设您有一个类及其伴随对象：

class Foo(a: String)

object Foo {
  def apply(a: String) = new Foo(a)
}

现在假设您想要编写一个方法，该方法接受对象

Foo

作为输入。它是什么类型的

如果你这样写：

def someMethod(fooObj: Foo) = fooObj.apply("x") // doesn't compile

它不会被编译

Foo

指类的实例类型（即

newfoo（“x”）

或

Foo（“x”）

返回的实例）。这就是为什么对象有一个

类型

成员可以引用自己的类型：

def someMethod(fooObj: Foo.type) = fooObj.apply("x") // compiles!

---

在您的特定示例中，

List.type

是

List

的伴随对象的类型。这里有几个例子，我希望能澄清它的含义：

val listObj: List.type = List
val anEmptyList: List[Int] = listObj.empty[Int] // List()
val aListOfIntegers: List[Int] = listObj.range(1, 4) // List[(1, 2, 3)

以及该类型如何与可以定义为trait中的字段的类型相关

type

关键字定义类型成员

.type

是类型成员。从概念上讲，Scala中的每个对象都有一个名为type的类型成员，如下所示：

object Foo {
  type type = Foo
}

---

显然，这不会编译，但它让您了解它可能是什么样子。

在类型级编程中，您会认为列表[+a]是一个类型构造函数：

即:

-列表[+A]采用类型参数（A）

-它本身不是有效的类型，您需要以某种方式填写“构造类型”

-用String填充它，您将得到List[String]，它是一种具体类型

在Scala中，说某事物属于List类型是无效的。Scala在这里更严格，不允许我们仅使用列表来代替类型，因为它需要的是一个真正的类型，而不是类型构造函数

简言之：

---

List[+A]是类型构造函数，而List[String]是实类型。

val x:Int=1

，

Int

是

x

的类型。您可以使用文本（

1

或

2

表示

Int

或

“James”

表示

String

）来使用某些类型（如

Int

或

String

）。类型构造函数是需要生成其他类型的类型<代码>列表或

选项

将不会是完全限定的类型，除非您将另一个类型传递给它们（即

列表[Int]

或

选项[String]

+1）。不仅回答了实际提出的问题，而且您还回答了我提出的“类型构造函数”问题，这让谷歌把我带到了这里。